/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */

#include <string.h>
#include <errno.h>
#include "testutil/testutil.h"
#include "nimble/ble.h"
#include "host/ble_uuid.h"
#include "host/ble_hs_test.h"
#include "ble_hs_test_util.h"

#define BLE_GATTS_NOTIFY_TEST_CHR_1_UUID    0x1111
#define BLE_GATTS_NOTIFY_TEST_CHR_2_UUID    0x2222

#define BLE_GATTS_NOTIFY_TEST_MAX_EVENTS    16

static uint8_t ble_gatts_notify_test_peer_addr[6] = {2,3,4,5,6,7};

static int
ble_gatts_notify_test_misc_access(uint16_t conn_handle,
                                  uint16_t attr_handle,
                                  struct ble_gatt_access_ctxt *ctxt,
                                  void *arg);
static void
ble_gatts_notify_test_misc_reg_cb(struct ble_gatt_register_ctxt *ctxt,
                                  void *arg);

static const struct ble_gatt_svc_def ble_gatts_notify_test_svcs[] = { {
    .type = BLE_GATT_SVC_TYPE_PRIMARY,
    .uuid = BLE_UUID16_DECLARE(0x1234),
    .characteristics = (struct ble_gatt_chr_def[]) { {
        .uuid = BLE_UUID16_DECLARE(BLE_GATTS_NOTIFY_TEST_CHR_1_UUID),
        .access_cb = ble_gatts_notify_test_misc_access,
        .flags = BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_NOTIFY |
                 BLE_GATT_CHR_F_INDICATE,
    }, {
        .uuid = BLE_UUID16_DECLARE(BLE_GATTS_NOTIFY_TEST_CHR_2_UUID),
        .access_cb = ble_gatts_notify_test_misc_access,
        .flags = BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_NOTIFY |
                 BLE_GATT_CHR_F_INDICATE,
    }, {
        0
    } },
}, {
    0
} };

static uint16_t ble_gatts_notify_test_chr_1_def_handle;
static uint8_t ble_gatts_notify_test_chr_1_val[1024];
static int ble_gatts_notify_test_chr_1_len;
static uint16_t ble_gatts_notify_test_chr_2_def_handle;
static uint8_t ble_gatts_notify_test_chr_2_val[1024];
static int ble_gatts_notify_test_chr_2_len;

static struct ble_gap_event
ble_gatts_notify_test_events[BLE_GATTS_NOTIFY_TEST_MAX_EVENTS];

static int ble_gatts_notify_test_num_events;

typedef int ble_store_write_fn(int obj_type, const union ble_store_value *val);

typedef int ble_store_delete_fn(int obj_type, const union ble_store_key *key);

static int
ble_gatts_notify_test_util_gap_event(struct ble_gap_event *event, void *arg)
{
    switch (event->type) {
    case BLE_GAP_EVENT_NOTIFY_TX:
    case BLE_GAP_EVENT_SUBSCRIBE:
        TEST_ASSERT_FATAL(ble_gatts_notify_test_num_events <
                          BLE_GATTS_NOTIFY_TEST_MAX_EVENTS);

        ble_gatts_notify_test_events[ble_gatts_notify_test_num_events++] =
            *event;

    default:
        break;
    }

    return 0;
}

static uint16_t
ble_gatts_notify_test_misc_read_notify(uint16_t conn_handle,
                                       uint16_t chr_def_handle)
{
    struct ble_att_read_req req;
    struct os_mbuf *om;
    uint8_t buf[BLE_ATT_READ_REQ_SZ];
    uint16_t flags;
    int rc;

    req.barq_handle = chr_def_handle + 2;
    ble_att_read_req_write(buf, sizeof buf, &req);

    rc = ble_hs_test_util_l2cap_rx_payload_flat(conn_handle, BLE_L2CAP_CID_ATT,
                                                buf, sizeof buf);
    TEST_ASSERT(rc == 0);

    om = ble_hs_test_util_prev_tx_dequeue_pullup();
    TEST_ASSERT_FATAL(om != NULL);
    TEST_ASSERT_FATAL(om->om_len == 3);
    TEST_ASSERT_FATAL(om->om_data[0] == BLE_ATT_OP_READ_RSP);

    flags = get_le16(om->om_data + 1);
    return flags;
}

static void
ble_gatts_notify_test_misc_try_enable_notify(uint16_t conn_handle,
                                             uint16_t chr_def_handle,
                                             uint16_t flags, int fail)
{
    struct ble_att_write_req req;
    uint8_t buf[BLE_ATT_WRITE_REQ_BASE_SZ + 2];
    int rc;

    req.bawq_handle = chr_def_handle + 2;
    ble_att_write_req_write(buf, sizeof buf, &req);

    put_le16(buf + BLE_ATT_WRITE_REQ_BASE_SZ, flags);
    rc = ble_hs_test_util_l2cap_rx_payload_flat(conn_handle, BLE_L2CAP_CID_ATT,
                                                buf, sizeof buf);
    if (fail) {
        TEST_ASSERT_FATAL(rc != 0);
        ble_hs_test_util_verify_tx_err_rsp(BLE_ATT_OP_WRITE_REQ,
                                           req.bawq_handle,
                                           BLE_ATT_ERR_REQ_NOT_SUPPORTED);
    } else {
        TEST_ASSERT_FATAL(rc == 0);
        ble_hs_test_util_verify_tx_write_rsp();
    }
}

static void
ble_gatts_notify_test_misc_enable_notify(uint16_t conn_handle,
                                         uint16_t chr_def_handle,
                                         uint16_t flags)
{
    ble_gatts_notify_test_misc_try_enable_notify(conn_handle,
                                                 chr_def_handle,
                                                 flags, 0);
}

static void
ble_gatts_notify_test_util_next_event(struct ble_gap_event *event)
{
    TEST_ASSERT_FATAL(ble_gatts_notify_test_num_events > 0);

    *event = *ble_gatts_notify_test_events;

    ble_gatts_notify_test_num_events--;
    if (ble_gatts_notify_test_num_events > 0) {
        memmove(ble_gatts_notify_test_events + 0,
                ble_gatts_notify_test_events + 1,
                ble_gatts_notify_test_num_events * sizeof *event);
    }
}

static void
ble_gatts_notify_test_util_verify_sub_event(uint16_t conn_handle,
                                            uint8_t attr_handle,
                                            uint8_t reason,
                                            uint8_t prevn, uint8_t curn,
                                            uint8_t previ, uint8_t curi)
{
    struct ble_gap_event event;

    ble_gatts_notify_test_util_next_event(&event);

    TEST_ASSERT(event.type == BLE_GAP_EVENT_SUBSCRIBE);
    TEST_ASSERT(event.subscribe.conn_handle == conn_handle);
    TEST_ASSERT(event.subscribe.attr_handle == attr_handle);
    TEST_ASSERT(event.subscribe.reason == reason);
    TEST_ASSERT(event.subscribe.prev_notify == prevn);
    TEST_ASSERT(event.subscribe.cur_notify == curn);
    TEST_ASSERT(event.subscribe.prev_indicate == previ);
    TEST_ASSERT(event.subscribe.cur_indicate == curi);
}

static void
ble_gatts_notify_test_util_verify_tx_event(uint16_t conn_handle,
                                           uint8_t attr_handle,
                                           int status,
                                           int indication)
{
    struct ble_gap_event event;

    ble_gatts_notify_test_util_next_event(&event);

    TEST_ASSERT(event.type == BLE_GAP_EVENT_NOTIFY_TX);
    TEST_ASSERT(event.notify_tx.status == status);
    TEST_ASSERT(event.notify_tx.conn_handle == conn_handle);
    TEST_ASSERT(event.notify_tx.attr_handle == attr_handle);
    TEST_ASSERT(event.notify_tx.indication == indication);
}

static void
ble_gatts_notify_test_util_verify_ack_event(uint16_t conn_handle,
                                            uint8_t attr_handle)
{
    ble_gatts_notify_test_util_verify_tx_event(conn_handle, attr_handle,
                                               BLE_HS_EDONE, 1);
}

static void
ble_gatts_notify_test_misc_init(uint16_t *out_conn_handle, int bonding,
                                uint16_t chr1_flags, uint16_t chr2_flags)
{
    struct ble_hs_conn *conn;
    uint16_t flags;
    int exp_num_cccds;

    ble_hs_test_util_init();
    ble_gatts_notify_test_num_events = 0;

    ble_hs_test_util_reg_svcs(ble_gatts_notify_test_svcs,
                              ble_gatts_notify_test_misc_reg_cb,
                              NULL);
    TEST_ASSERT_FATAL(ble_gatts_notify_test_chr_1_def_handle != 0);
    TEST_ASSERT_FATAL(ble_gatts_notify_test_chr_2_def_handle != 0);

    ble_hs_test_util_create_conn(2, ble_gatts_notify_test_peer_addr,
                                 ble_gatts_notify_test_util_gap_event, NULL);
    *out_conn_handle = 2;

    if (bonding) {
        ble_hs_lock();
        conn = ble_hs_conn_find(2);
        TEST_ASSERT_FATAL(conn != NULL);
        conn->bhc_sec_state.encrypted = 1;
        conn->bhc_sec_state.authenticated = 1;
        conn->bhc_sec_state.bonded = 1;
        ble_hs_unlock();
    }

    /* Ensure notifications disabled on new connection. */
    flags = ble_gatts_notify_test_misc_read_notify(
        2, ble_gatts_notify_test_chr_1_def_handle);
    TEST_ASSERT(flags == 0);
    flags = ble_gatts_notify_test_misc_read_notify(
        2, ble_gatts_notify_test_chr_2_def_handle);
    TEST_ASSERT(flags == 0);

    /* Set initial notification / indication state and verify that subscription
     * callback gets executed.
     */
    if (chr1_flags != 0) {
        ble_gatts_notify_test_misc_enable_notify(
            2, ble_gatts_notify_test_chr_1_def_handle, chr1_flags);

        ble_gatts_notify_test_util_verify_sub_event(
            *out_conn_handle,
            ble_gatts_notify_test_chr_1_def_handle + 1,
            BLE_GAP_SUBSCRIBE_REASON_WRITE,
            0, chr1_flags == BLE_GATTS_CLT_CFG_F_NOTIFY,
            0, chr1_flags == BLE_GATTS_CLT_CFG_F_INDICATE);
    }
    if (chr2_flags != 0) {
        ble_gatts_notify_test_misc_enable_notify(
            2, ble_gatts_notify_test_chr_2_def_handle, chr2_flags);

        ble_gatts_notify_test_util_verify_sub_event(
            *out_conn_handle,
            ble_gatts_notify_test_chr_2_def_handle + 1,
            BLE_GAP_SUBSCRIBE_REASON_WRITE,
            0, chr2_flags == BLE_GATTS_CLT_CFG_F_NOTIFY,
            0, chr2_flags == BLE_GATTS_CLT_CFG_F_INDICATE);
    }

    /* Ensure no extraneous subscription callbacks were executed. */
    TEST_ASSERT(ble_gatts_notify_test_num_events == 0);

    /* Toss both write responses. */
    ble_hs_test_util_prev_tx_queue_clear();

    /* Ensure notification / indication state reads back correctly. */
    flags = ble_gatts_notify_test_misc_read_notify(
        2, ble_gatts_notify_test_chr_1_def_handle);
    TEST_ASSERT(flags == chr1_flags);
    flags = ble_gatts_notify_test_misc_read_notify(
        2, ble_gatts_notify_test_chr_2_def_handle);
    TEST_ASSERT(flags == chr2_flags);

    /* Ensure both CCCDs still persisted. */
    if (bonding) {
        exp_num_cccds = (chr1_flags != 0) + (chr2_flags != 0);
    } else {
        exp_num_cccds = 0;
    }
    TEST_ASSERT(ble_hs_test_util_num_cccds() == exp_num_cccds);
}

static void
ble_gatts_notify_test_disconnect(uint16_t conn_handle,
                                 uint8_t chr1_flags,
                                 uint8_t chr1_indicate_in_progress,
                                 uint8_t chr2_flags,
                                 uint8_t chr2_indicate_in_progress)
{
    ble_hs_test_util_conn_disconnect(conn_handle);

    if (chr1_indicate_in_progress) {
        ble_gatts_notify_test_util_verify_tx_event(
            conn_handle,
            ble_gatts_notify_test_chr_1_def_handle + 1,
            BLE_HS_ENOTCONN,
            1);
    }

    /* Verify subscription callback executed for each subscribed
     * characteristic.
     */
    if (chr1_flags != 0) {
        ble_gatts_notify_test_util_verify_sub_event(
            conn_handle,
            ble_gatts_notify_test_chr_1_def_handle + 1,
            BLE_GAP_SUBSCRIBE_REASON_TERM,
            chr1_flags == BLE_GATTS_CLT_CFG_F_NOTIFY, 0,
            chr1_flags == BLE_GATTS_CLT_CFG_F_INDICATE, 0);
    }

    if (chr2_indicate_in_progress) {
        ble_gatts_notify_test_util_verify_tx_event(
            conn_handle,
            ble_gatts_notify_test_chr_2_def_handle + 1,
            BLE_HS_ENOTCONN,
            1);
    }

    if (chr2_flags != 0) {
        ble_gatts_notify_test_util_verify_sub_event(
            conn_handle,
            ble_gatts_notify_test_chr_2_def_handle + 1,
            BLE_GAP_SUBSCRIBE_REASON_TERM,
            chr2_flags == BLE_GATTS_CLT_CFG_F_NOTIFY, 0,
            chr2_flags == BLE_GATTS_CLT_CFG_F_INDICATE, 0);
    }
}

static void
ble_gatts_notify_test_misc_reg_cb(struct ble_gatt_register_ctxt *ctxt,
                                  void *arg)
{
    uint16_t uuid16;

    if (ctxt->op == BLE_GATT_REGISTER_OP_CHR) {
        uuid16 = ble_uuid_u16(ctxt->chr.chr_def->uuid);
        switch (uuid16) {
        case BLE_GATTS_NOTIFY_TEST_CHR_1_UUID:
            ble_gatts_notify_test_chr_1_def_handle = ctxt->chr.def_handle;
            break;

        case BLE_GATTS_NOTIFY_TEST_CHR_2_UUID:
            ble_gatts_notify_test_chr_2_def_handle = ctxt->chr.def_handle;
            break;

        default:
            TEST_ASSERT_FATAL(0);
            break;
        }
    }
}

static int
ble_gatts_notify_test_misc_access(uint16_t conn_handle,
                                  uint16_t attr_handle,
                                  struct ble_gatt_access_ctxt *ctxt,
                                  void *arg)
{
    int rc;

    TEST_ASSERT_FATAL(ctxt->op == BLE_GATT_ACCESS_OP_READ_CHR);
    TEST_ASSERT(conn_handle == 0xffff);

    if (attr_handle == ble_gatts_notify_test_chr_1_def_handle + 1) {
        TEST_ASSERT(ctxt->chr ==
                    &ble_gatts_notify_test_svcs[0].characteristics[0]);
        rc = os_mbuf_copyinto(ctxt->om, 0, ble_gatts_notify_test_chr_1_val,
                              ble_gatts_notify_test_chr_1_len);
        TEST_ASSERT_FATAL(rc == 0);
    } else if (attr_handle == ble_gatts_notify_test_chr_2_def_handle + 1) {
        TEST_ASSERT(ctxt->chr ==
                    &ble_gatts_notify_test_svcs[0].characteristics[1]);
        rc = os_mbuf_copyinto(ctxt->om, 0, ble_gatts_notify_test_chr_2_val,
                              ble_gatts_notify_test_chr_2_len);
        TEST_ASSERT_FATAL(rc == 0);
    } else {
        TEST_ASSERT_FATAL(0);
    }

    return 0;
}

static void
ble_gatts_notify_test_misc_rx_indicate_rsp(uint16_t conn_handle,
                                           uint16_t attr_handle)
{
    uint8_t buf[BLE_ATT_INDICATE_RSP_SZ];
    int rc;

    ble_att_indicate_rsp_write(buf, sizeof buf);

    rc = ble_hs_test_util_l2cap_rx_payload_flat(conn_handle, BLE_L2CAP_CID_ATT,
                                                buf, sizeof buf);
    TEST_ASSERT(rc == 0);

    ble_gatts_notify_test_util_verify_ack_event(conn_handle, attr_handle);
}

static void
ble_gatts_notify_test_misc_verify_tx_n(uint16_t conn_handle,
                                       uint16_t attr_handle,
                                       const uint8_t *attr_data, int attr_len)
{
    struct ble_att_notify_req req;
    struct os_mbuf *om;
    int i;

    om = ble_hs_test_util_prev_tx_dequeue_pullup();
    TEST_ASSERT_FATAL(om != NULL);

    ble_att_notify_req_parse(om->om_data, om->om_len, &req);
    TEST_ASSERT(req.banq_handle == attr_handle);

    for (i = 0; i < attr_len; i++) {
        TEST_ASSERT(om->om_data[BLE_ATT_NOTIFY_REQ_BASE_SZ + i] ==
                    attr_data[i]);
    }

    ble_gatts_notify_test_util_verify_tx_event(conn_handle, attr_handle, 0, 0);
}

static void
ble_gatts_notify_test_misc_verify_tx_i(uint16_t conn_handle,
                                       uint16_t attr_handle,
                                       const uint8_t *attr_data, int attr_len)
{
    struct ble_att_indicate_req req;
    struct os_mbuf *om;
    int i;

    om = ble_hs_test_util_prev_tx_dequeue_pullup();
    TEST_ASSERT_FATAL(om != NULL);

    ble_att_indicate_req_parse(om->om_data, om->om_len, &req);
    TEST_ASSERT(req.baiq_handle == attr_handle);

    for (i = 0; i < attr_len; i++) {
        TEST_ASSERT(om->om_data[BLE_ATT_INDICATE_REQ_BASE_SZ + i] ==
                    attr_data[i]);
    }

    ble_gatts_notify_test_util_verify_tx_event(conn_handle, attr_handle, 0, 1);
}

static void
ble_gatts_notify_test_misc_verify_tx_gen(uint16_t conn_handle, int attr_idx,
                                         uint8_t chr_flags)
{
    uint16_t attr_handle;
    uint16_t attr_len;
    void *attr_val;

    switch (attr_idx) {
    case 1:
        attr_handle = ble_gatts_notify_test_chr_1_def_handle + 1;
        attr_len = ble_gatts_notify_test_chr_1_len;
        attr_val = ble_gatts_notify_test_chr_1_val;
        break;

    case 2:
        attr_handle = ble_gatts_notify_test_chr_2_def_handle + 1;
        attr_len = ble_gatts_notify_test_chr_2_len;
        attr_val = ble_gatts_notify_test_chr_2_val;
        break;

    default:
        TEST_ASSERT_FATAL(0);
        break;
    }

    switch (chr_flags) {
    case 0:
        break;

    case BLE_GATTS_CLT_CFG_F_NOTIFY:
        ble_gatts_notify_test_misc_verify_tx_n(conn_handle, attr_handle,
                                               attr_val, attr_len);
        break;

    case BLE_GATTS_CLT_CFG_F_INDICATE:
        ble_gatts_notify_test_misc_verify_tx_i(conn_handle, attr_handle,
                                               attr_val, attr_len);
        break;

    default:
        TEST_ASSERT_FATAL(0);
        break;
    }
}

static void
ble_gatts_notify_test_restore_bonding(uint16_t conn_handle,
                                      uint8_t chr1_flags, uint8_t chr1_tx,
                                      uint8_t chr2_flags, uint8_t chr2_tx)
{
    struct ble_hs_conn *conn;

    ble_hs_lock();
    conn = ble_hs_conn_find(conn_handle);
    TEST_ASSERT_FATAL(conn != NULL);
    conn->bhc_sec_state.encrypted = 1;
    conn->bhc_sec_state.authenticated = 1;
    conn->bhc_sec_state.bonded = 1;
    ble_hs_unlock();

    ble_gatts_bonding_restored(conn_handle);

    /* Verify subscription callback executed for each subscribed
     * characteristic.
     */
    if (chr1_flags != 0) {
        ble_gatts_notify_test_util_verify_sub_event(
            conn_handle,
            ble_gatts_notify_test_chr_1_def_handle + 1,
            BLE_GAP_SUBSCRIBE_REASON_RESTORE,
            0, chr1_flags == BLE_GATTS_CLT_CFG_F_NOTIFY,
            0, chr1_flags == BLE_GATTS_CLT_CFG_F_INDICATE);

    }
    if (chr1_tx) {
        ble_gatts_notify_test_misc_verify_tx_gen(conn_handle, 1, chr1_flags);
    }

    if (chr2_flags != 0) {
        ble_gatts_notify_test_util_verify_sub_event(
            conn_handle,
            ble_gatts_notify_test_chr_2_def_handle + 1,
            BLE_GAP_SUBSCRIBE_REASON_RESTORE,
            0, chr2_flags == BLE_GATTS_CLT_CFG_F_NOTIFY,
            0, chr2_flags == BLE_GATTS_CLT_CFG_F_INDICATE);
    }
    if (chr2_tx) {
        ble_gatts_notify_test_misc_verify_tx_gen(conn_handle, 2, chr2_flags);
    }
}

TEST_CASE(ble_gatts_notify_test_n)
{
    static const uint8_t fourbytes[] = { 1, 2, 3, 4 };
    struct os_mbuf *om;
    uint16_t conn_handle;
    uint16_t flags;
    int rc;

    ble_gatts_notify_test_misc_init(&conn_handle, 0,
                                    BLE_GATTS_CLT_CFG_F_NOTIFY,
                                    BLE_GATTS_CLT_CFG_F_NOTIFY);

    /* Ensure notifications read back as enabled. */
    flags = ble_gatts_notify_test_misc_read_notify(
        conn_handle, ble_gatts_notify_test_chr_1_def_handle);
    TEST_ASSERT(flags == BLE_GATTS_CLT_CFG_F_NOTIFY);
    flags = ble_gatts_notify_test_misc_read_notify(
        conn_handle, ble_gatts_notify_test_chr_2_def_handle);
    TEST_ASSERT(flags == BLE_GATTS_CLT_CFG_F_NOTIFY);

    /* Verify custom notification data. */
    om = ble_hs_mbuf_from_flat(fourbytes, sizeof fourbytes);
    TEST_ASSERT_FATAL(om != NULL);

    rc = ble_gattc_notify_custom(conn_handle,
                                 ble_gatts_notify_test_chr_1_def_handle + 1,
                                 om);
    TEST_ASSERT_FATAL(rc == 0);

    ble_gatts_notify_test_misc_verify_tx_n(
        conn_handle,
        ble_gatts_notify_test_chr_1_def_handle + 1,
        fourbytes,
        sizeof fourbytes);

    /* Update characteristic 1's value. */
    ble_gatts_notify_test_chr_1_len = 1;
    ble_gatts_notify_test_chr_1_val[0] = 0xab;
    ble_gatts_chr_updated(ble_gatts_notify_test_chr_1_def_handle + 1);

    /* Verify notification sent properly. */
    ble_gatts_notify_test_misc_verify_tx_n(
        conn_handle,
        ble_gatts_notify_test_chr_1_def_handle + 1,
        ble_gatts_notify_test_chr_1_val,
        ble_gatts_notify_test_chr_1_len);

    /* Update characteristic 2's value. */
    ble_gatts_notify_test_chr_2_len = 16;
    memcpy(ble_gatts_notify_test_chr_2_val,
           ((uint8_t[]){0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}), 16);
    ble_gatts_chr_updated(ble_gatts_notify_test_chr_2_def_handle + 1);

    /* Verify notification sent properly. */
    ble_gatts_notify_test_misc_verify_tx_n(
        conn_handle,
        ble_gatts_notify_test_chr_2_def_handle + 1,
        ble_gatts_notify_test_chr_2_val,
        ble_gatts_notify_test_chr_2_len);

    /***
     * Disconnect, modify characteristic values, and reconnect.  Ensure
     * notifications are not sent and are no longer enabled.
     */

    ble_gatts_notify_test_disconnect(conn_handle,
                                     BLE_GATTS_CLT_CFG_F_NOTIFY, 0,
                                     BLE_GATTS_CLT_CFG_F_NOTIFY, 0);

    /* Update characteristic 1's value. */
    ble_gatts_notify_test_chr_1_len = 1;
    ble_gatts_notify_test_chr_1_val[0] = 0xdd;
    ble_gatts_chr_updated(ble_gatts_notify_test_chr_1_def_handle + 1);

    /* Update characteristic 2's value. */
    ble_gatts_notify_test_chr_2_len = 16;
    memcpy(ble_gatts_notify_test_chr_2_val,
           ((uint8_t[]){1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}), 16);
    ble_gatts_chr_updated(ble_gatts_notify_test_chr_2_def_handle + 1);

    ble_hs_test_util_create_conn(conn_handle, ((uint8_t[]){2,3,4,5,6,7,8,9}),
                                 ble_gatts_notify_test_util_gap_event, NULL);

    /* Ensure no notifications sent. */
    TEST_ASSERT(ble_hs_test_util_prev_tx_dequeue() == NULL);

    /* Ensure notifications disabled. */
    flags = ble_gatts_notify_test_misc_read_notify(
        conn_handle, ble_gatts_notify_test_chr_1_def_handle);
    TEST_ASSERT(flags == 0);
    flags = ble_gatts_notify_test_misc_read_notify(
        conn_handle, ble_gatts_notify_test_chr_2_def_handle);
    TEST_ASSERT(flags == 0);
}

TEST_CASE(ble_gatts_notify_test_i)
{
    static const uint8_t fourbytes[] = { 1, 2, 3, 4 };
    struct os_mbuf *om;
    uint16_t conn_handle;
    uint16_t flags;
    int rc;

    ble_gatts_notify_test_misc_init(&conn_handle, 0,
                                    BLE_GATTS_CLT_CFG_F_INDICATE,
                                    BLE_GATTS_CLT_CFG_F_INDICATE);

    /* Verify custom indication data. */
    om = ble_hs_mbuf_from_flat(fourbytes, sizeof fourbytes);
    TEST_ASSERT_FATAL(om != NULL);

    rc = ble_gattc_indicate_custom(conn_handle,
                                   ble_gatts_notify_test_chr_1_def_handle + 1,
                                   om);
    TEST_ASSERT_FATAL(rc == 0);

    ble_gatts_notify_test_misc_verify_tx_i(
        conn_handle,
        ble_gatts_notify_test_chr_1_def_handle + 1,
        fourbytes,
        sizeof fourbytes);

    /* Receive the confirmation for the indication. */
    ble_gatts_notify_test_misc_rx_indicate_rsp(
        conn_handle,
        ble_gatts_notify_test_chr_1_def_handle + 1);

    /* Update characteristic 1's value. */
    ble_gatts_notify_test_chr_1_len = 1;
    ble_gatts_notify_test_chr_1_val[0] = 0xab;
    ble_gatts_chr_updated(ble_gatts_notify_test_chr_1_def_handle + 1);

    /* Verify indication sent properly. */
    ble_gatts_notify_test_misc_verify_tx_i(
        conn_handle,
        ble_gatts_notify_test_chr_1_def_handle + 1,
        ble_gatts_notify_test_chr_1_val,
        ble_gatts_notify_test_chr_1_len);

    /* Update characteristic 2's value. */
    ble_gatts_notify_test_chr_2_len = 16;
    memcpy(ble_gatts_notify_test_chr_2_val,
           ((uint8_t[]){0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}), 16);
    ble_gatts_chr_updated(ble_gatts_notify_test_chr_2_def_handle + 1);

    /* Verify the second indication doesn't get sent until the first is
     * confirmed.
     */
    TEST_ASSERT(ble_hs_test_util_prev_tx_queue_sz() == 0);

    /* Receive the confirmation for the first indication. */
    ble_gatts_notify_test_misc_rx_indicate_rsp(
        conn_handle,
        ble_gatts_notify_test_chr_1_def_handle + 1);

    /* Verify indication sent properly. */
    ble_gatts_notify_test_misc_verify_tx_i(
        conn_handle,
        ble_gatts_notify_test_chr_2_def_handle + 1,
        ble_gatts_notify_test_chr_2_val,
        ble_gatts_notify_test_chr_2_len);

    /* Receive the confirmation for the second indication. */
    ble_gatts_notify_test_misc_rx_indicate_rsp(
        conn_handle,
        ble_gatts_notify_test_chr_2_def_handle + 1);

    /* Verify no pending GATT jobs. */
    TEST_ASSERT(!ble_gattc_any_jobs());

    /***
     * Disconnect, modify characteristic values, and reconnect.  Ensure
     * indications are not sent and are no longer enabled.
     */

    ble_gatts_notify_test_disconnect(conn_handle,
                                     BLE_GATTS_CLT_CFG_F_INDICATE, 0,
                                     BLE_GATTS_CLT_CFG_F_INDICATE, 0);

    /* Update characteristic 1's value. */
    ble_gatts_notify_test_chr_1_len = 1;
    ble_gatts_notify_test_chr_1_val[0] = 0xdd;
    ble_gatts_chr_updated(ble_gatts_notify_test_chr_1_def_handle + 1);

    /* Update characteristic 2's value. */
    ble_gatts_notify_test_chr_2_len = 16;
    memcpy(ble_gatts_notify_test_chr_2_val,
           ((uint8_t[]){1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}), 16);
    ble_gatts_chr_updated(ble_gatts_notify_test_chr_2_def_handle + 1);

    ble_hs_test_util_create_conn(conn_handle, ((uint8_t[]){2,3,4,5,6,7,8,9}),
                                 ble_gatts_notify_test_util_gap_event, NULL);

    /* Ensure no indications sent. */
    TEST_ASSERT(ble_hs_test_util_prev_tx_dequeue() == NULL);

    /* Ensure indications disabled. */
    flags = ble_gatts_notify_test_misc_read_notify(
        conn_handle, ble_gatts_notify_test_chr_1_def_handle);
    TEST_ASSERT(flags == 0);
    flags = ble_gatts_notify_test_misc_read_notify(
        conn_handle, ble_gatts_notify_test_chr_2_def_handle);
    TEST_ASSERT(flags == 0);
}

TEST_CASE(ble_gatts_notify_test_bonded_n)
{
    uint16_t conn_handle;
    uint16_t flags;

    ble_gatts_notify_test_misc_init(&conn_handle, 1,
                                    BLE_GATTS_CLT_CFG_F_NOTIFY,
                                    BLE_GATTS_CLT_CFG_F_NOTIFY);

    /* Disconnect. */
    ble_gatts_notify_test_disconnect(conn_handle,
                                     BLE_GATTS_CLT_CFG_F_NOTIFY, 0,
                                     BLE_GATTS_CLT_CFG_F_NOTIFY, 0);

    /* Ensure both CCCDs still persisted. */
    TEST_ASSERT(ble_hs_test_util_num_cccds() == 2);

    /* Update characteristic 1's value. */
    ble_gatts_notify_test_chr_1_len = 1;
    ble_gatts_notify_test_chr_1_val[0] = 0xdd;
    ble_gatts_chr_updated(ble_gatts_notify_test_chr_1_def_handle + 1);

    /* Update characteristic 2's value. */
    ble_gatts_notify_test_chr_2_len = 16;
    memcpy(ble_gatts_notify_test_chr_2_val,
           ((uint8_t[]){1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}), 16);
    ble_gatts_chr_updated(ble_gatts_notify_test_chr_2_def_handle + 1);

    /* Reconnect; ensure notifications don't get sent while unbonded and that
     * notifications appear disabled.
     */

    ble_hs_test_util_create_conn(conn_handle, ((uint8_t[]){2,3,4,5,6,7,8,9}),
                                 ble_gatts_notify_test_util_gap_event, NULL);

    ble_gatts_notify_test_num_events = 0;
    /* Ensure no notifications sent. */
    TEST_ASSERT(ble_hs_test_util_prev_tx_dequeue() == NULL);

    /* Ensure notifications disabled. */
    flags = ble_gatts_notify_test_misc_read_notify(
        conn_handle, ble_gatts_notify_test_chr_1_def_handle);
    TEST_ASSERT(flags == 0);
    flags = ble_gatts_notify_test_misc_read_notify(
        conn_handle, ble_gatts_notify_test_chr_2_def_handle);
    TEST_ASSERT(flags == 0);

    /* Simulate a successful encryption procedure (bonding restoration). */
    ble_gatts_notify_test_restore_bonding(conn_handle,
                                          BLE_GATTS_CLT_CFG_F_NOTIFY, 1,
                                          BLE_GATTS_CLT_CFG_F_NOTIFY, 1);

    /* Ensure notifications enabled. */
    flags = ble_gatts_notify_test_misc_read_notify(
        conn_handle, ble_gatts_notify_test_chr_1_def_handle);
    TEST_ASSERT(flags == BLE_GATTS_CLT_CFG_F_NOTIFY);
    flags = ble_gatts_notify_test_misc_read_notify(
        conn_handle, ble_gatts_notify_test_chr_2_def_handle);
    TEST_ASSERT(flags == BLE_GATTS_CLT_CFG_F_NOTIFY);

    /* Ensure both CCCDs still persisted. */
    TEST_ASSERT(ble_hs_test_util_num_cccds() == 2);
}

TEST_CASE(ble_gatts_notify_test_bonded_i)
{
    uint16_t conn_handle;
    uint16_t flags;

    ble_gatts_notify_test_misc_init(&conn_handle, 1,
                                    BLE_GATTS_CLT_CFG_F_INDICATE,
                                    BLE_GATTS_CLT_CFG_F_INDICATE);

    /* Disconnect. */
    ble_gatts_notify_test_disconnect(conn_handle,
                                     BLE_GATTS_CLT_CFG_F_INDICATE, 0,
                                     BLE_GATTS_CLT_CFG_F_INDICATE, 0);

    /* Ensure both CCCDs still persisted. */
    TEST_ASSERT(ble_hs_test_util_num_cccds() == 2);

    /* Update characteristic 1's value. */
    ble_gatts_notify_test_chr_1_len = 1;
    ble_gatts_notify_test_chr_1_val[0] = 0xab;
    ble_gatts_chr_updated(ble_gatts_notify_test_chr_1_def_handle + 1);

    /* Update characteristic 2's value. */
    ble_gatts_notify_test_chr_2_len = 16;
    memcpy(ble_gatts_notify_test_chr_2_val,
           ((uint8_t[]){0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}), 16);
    ble_gatts_chr_updated(ble_gatts_notify_test_chr_2_def_handle + 1);

    /* Reconnect; ensure notifications don't get sent while unbonded and that
     * notifications appear disabled.
     */

    ble_hs_test_util_create_conn(conn_handle, ((uint8_t[]){2,3,4,5,6,7,8,9}),
                                 ble_gatts_notify_test_util_gap_event, NULL);

    /* Ensure no indications sent. */
    TEST_ASSERT(ble_hs_test_util_prev_tx_dequeue() == NULL);

    /* Ensure notifications disabled. */
    flags = ble_gatts_notify_test_misc_read_notify(
        conn_handle, ble_gatts_notify_test_chr_1_def_handle);
    TEST_ASSERT(flags == 0);
    flags = ble_gatts_notify_test_misc_read_notify(
        conn_handle, ble_gatts_notify_test_chr_2_def_handle);
    TEST_ASSERT(flags == 0);

    /* Simulate a successful encryption procedure (bonding restoration). */
    ble_gatts_notify_test_restore_bonding(conn_handle,
                                          BLE_GATTS_CLT_CFG_F_INDICATE, 1,
                                          BLE_GATTS_CLT_CFG_F_INDICATE, 0);

    /* Verify the second indication doesn't get sent until the first is
     * confirmed.
     */
    TEST_ASSERT(ble_hs_test_util_prev_tx_queue_sz() == 0);

    /* Receive the confirmation for the first indication. */
    ble_gatts_notify_test_misc_rx_indicate_rsp(
        conn_handle,
        ble_gatts_notify_test_chr_1_def_handle + 1);

    /* Verify indication sent properly. */
    ble_gatts_notify_test_misc_verify_tx_i(
        conn_handle,
        ble_gatts_notify_test_chr_2_def_handle + 1,
        ble_gatts_notify_test_chr_2_val,
        ble_gatts_notify_test_chr_2_len);

    /* Receive the confirmation for the second indication. */
    ble_gatts_notify_test_misc_rx_indicate_rsp(
        conn_handle,
        ble_gatts_notify_test_chr_2_def_handle + 1);

    /* Verify no pending GATT jobs. */
    TEST_ASSERT(!ble_gattc_any_jobs());

    /* Ensure notifications enabled. */
    flags = ble_gatts_notify_test_misc_read_notify(
        conn_handle, ble_gatts_notify_test_chr_1_def_handle);
    TEST_ASSERT(flags == BLE_GATTS_CLT_CFG_F_INDICATE);
    flags = ble_gatts_notify_test_misc_read_notify(
        conn_handle, ble_gatts_notify_test_chr_2_def_handle);
    TEST_ASSERT(flags == BLE_GATTS_CLT_CFG_F_INDICATE);

    /* Ensure both CCCDs still persisted. */
    TEST_ASSERT(ble_hs_test_util_num_cccds() == 2);
}

TEST_CASE(ble_gatts_notify_test_bonded_i_no_ack)
{
    struct ble_store_value_cccd value_cccd;
    struct ble_store_key_cccd key_cccd;
    uint16_t conn_handle;
    uint16_t flags;
    int rc;

    ble_gatts_notify_test_misc_init(&conn_handle, 1,
                                    BLE_GATTS_CLT_CFG_F_INDICATE, 0);

    /* Update characteristic 1's value. */
    ble_gatts_notify_test_chr_1_len = 1;
    ble_gatts_notify_test_chr_1_val[0] = 0xab;
    ble_gatts_chr_updated(ble_gatts_notify_test_chr_1_def_handle + 1);

    /* Verify indication sent properly. */
    ble_gatts_notify_test_misc_verify_tx_i(
        conn_handle,
        ble_gatts_notify_test_chr_1_def_handle + 1,
        ble_gatts_notify_test_chr_1_val,
        ble_gatts_notify_test_chr_1_len);

    /* Verify 'updated' state is still persisted. */
    key_cccd.peer_addr = *BLE_ADDR_ANY;
    key_cccd.chr_val_handle = ble_gatts_notify_test_chr_1_def_handle + 1;
    key_cccd.idx = 0;

    rc = ble_store_read_cccd(&key_cccd, &value_cccd);
    TEST_ASSERT_FATAL(rc == 0);
    TEST_ASSERT(value_cccd.value_changed);

    /* Disconnect. */
    ble_gatts_notify_test_disconnect(conn_handle,
                                     BLE_GATTS_CLT_CFG_F_INDICATE, 1, 0, 0);

    /* Ensure CCCD still persisted. */
    TEST_ASSERT(ble_hs_test_util_num_cccds() == 1);

    /* Reconnect. */
    ble_hs_test_util_create_conn(conn_handle, ((uint8_t[]){2,3,4,5,6,7,8,9}),
                                 ble_gatts_notify_test_util_gap_event, NULL);

    /* Simulate a successful encryption procedure (bonding restoration). */
    ble_gatts_notify_test_restore_bonding(conn_handle,
                                          BLE_GATTS_CLT_CFG_F_INDICATE, 1,
                                          0, 0);

    /* Receive the confirmation for the indication. */
    ble_gatts_notify_test_misc_rx_indicate_rsp(
        conn_handle,
        ble_gatts_notify_test_chr_1_def_handle + 1);

    /* Verify no pending GATT jobs. */
    TEST_ASSERT(!ble_gattc_any_jobs());

    /* Ensure indication enabled. */
    flags = ble_gatts_notify_test_misc_read_notify(
        conn_handle, ble_gatts_notify_test_chr_1_def_handle);
    TEST_ASSERT(flags == BLE_GATTS_CLT_CFG_F_INDICATE);
    flags = ble_gatts_notify_test_misc_read_notify(
        conn_handle, ble_gatts_notify_test_chr_2_def_handle);
    TEST_ASSERT(flags == 0);

    /* Ensure CCCD still persisted. */
    TEST_ASSERT(ble_hs_test_util_num_cccds() == 1);

    /* Verify 'updated' state is no longer persisted. */
    rc = ble_store_read_cccd(&key_cccd, &value_cccd);
    TEST_ASSERT_FATAL(rc == 0);
    TEST_ASSERT(!value_cccd.value_changed);
}

TEST_CASE(ble_gatts_notify_test_disallowed)
{
    uint16_t chr1_val_handle;
    uint16_t chr2_val_handle;
    uint16_t chr3_val_handle;

    const struct ble_gatt_svc_def svcs[] = { {
        .type = BLE_GATT_SVC_TYPE_PRIMARY,
        .uuid = BLE_UUID16_DECLARE(0x1234),
        .characteristics = (struct ble_gatt_chr_def[]) { {
            .uuid = BLE_UUID16_DECLARE(1),
            .access_cb = ble_gatts_notify_test_misc_access,
            .flags = BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_NOTIFY,
            .val_handle = &chr1_val_handle,
        }, {
            .uuid = BLE_UUID16_DECLARE(2),
            .access_cb = ble_gatts_notify_test_misc_access,
            .flags = BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_INDICATE,
            .val_handle = &chr2_val_handle,
        }, {
            .uuid = BLE_UUID16_DECLARE(3),
            .access_cb = ble_gatts_notify_test_misc_access,
            .flags = BLE_GATT_CHR_F_READ | BLE_GATT_CHR_F_NOTIFY |
                     BLE_GATT_CHR_F_INDICATE,
            .val_handle = &chr3_val_handle,
        }, {
            0
        } },
    }, {
        0
    } };

    ble_hs_test_util_init();

    ble_hs_test_util_reg_svcs(svcs, NULL, NULL);
    TEST_ASSERT_FATAL(chr1_val_handle != 0);
    TEST_ASSERT_FATAL(chr2_val_handle != 0);
    TEST_ASSERT_FATAL(chr3_val_handle != 0);

    ble_hs_test_util_create_conn(2, ble_gatts_notify_test_peer_addr,
                                 ble_gatts_notify_test_util_gap_event, NULL);

    /* Attempt to enable notifications on chr1 should succeed. */
    ble_gatts_notify_test_misc_try_enable_notify(
        2, chr1_val_handle - 1, BLE_GATTS_CLT_CFG_F_NOTIFY, 0);

    /* Attempt to enable indications on chr1 should fail. */
    ble_gatts_notify_test_misc_try_enable_notify(
        2, chr1_val_handle - 1, BLE_GATTS_CLT_CFG_F_INDICATE, 1);

    /* Attempt to enable notifications on chr2 should fail. */
    ble_gatts_notify_test_misc_try_enable_notify(
        2, chr2_val_handle - 1, BLE_GATTS_CLT_CFG_F_NOTIFY, 1);

    /* Attempt to enable indications on chr2 should succeed. */
    ble_gatts_notify_test_misc_try_enable_notify(
        2, chr2_val_handle - 1, BLE_GATTS_CLT_CFG_F_INDICATE, 0);

    /* Attempt to enable notifications on chr3 should succeed. */
    ble_gatts_notify_test_misc_try_enable_notify(
        2, chr3_val_handle - 1, BLE_GATTS_CLT_CFG_F_NOTIFY, 0);

    /* Attempt to enable indications on chr3 should succeed. */
    ble_gatts_notify_test_misc_try_enable_notify(
        2, chr3_val_handle - 1, BLE_GATTS_CLT_CFG_F_INDICATE, 0);
}

TEST_SUITE(ble_gatts_notify_suite)
{
    tu_suite_set_post_test_cb(ble_hs_test_util_post_test, NULL);

    ble_gatts_notify_test_n();
    ble_gatts_notify_test_i();

    ble_gatts_notify_test_bonded_n();
    ble_gatts_notify_test_bonded_i();

    ble_gatts_notify_test_bonded_i_no_ack();

    ble_gatts_notify_test_disallowed();

    /* XXX: Test corner cases:
     *     o Bonding after CCCD configuration.
     *     o Disconnect prior to rx of indicate ack.
     */
}

int
ble_gatts_notify_test_all(void)
{
    ble_gatts_notify_suite();

    return tu_any_failed;
}