// 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.

#include <string.h>
#include <errno.h>

#include "sdkconfig.h"

#include "mesh_bearer_adapt.h"
#include "mesh_trace.h"

#include "net.h"
#include "beacon.h"
#include "foundation.h"
#include "provisioner_prov.h"
#include "provisioner_proxy.h"
#include "provisioner_beacon.h"

#if CONFIG_BLE_MESH_PROVISIONER

#define PDU_TYPE(data)      (data[0] & BIT_MASK(6))
#define PDU_SAR(data)       (data[0] >> 6)

#define SAR_COMPLETE        0x00
#define SAR_FIRST           0x01
#define SAR_CONT            0x02
#define SAR_LAST            0x03

#define CFG_FILTER_SET      0x00
#define CFG_FILTER_ADD      0x01
#define CFG_FILTER_REMOVE   0x02
#define CFG_FILTER_STATUS   0x03

#define PDU_HDR(sar, type)  (sar << 6 | (type & BIT_MASK(6)))

#define SERVER_BUF_SIZE     68

#define ID_TYPE_NET         0x00
#define ID_TYPE_NODE        0x01

#define NODE_ID_LEN         19
#define NET_ID_LEN          11

#define CLOSE_REASON_PROXY  0xFF

static int conn_count;

static struct bt_mesh_proxy_server {
    struct bt_mesh_conn *conn;
    /* Provisioner can use filter to double check the dst within mesh messages */
    u16_t filter[CONFIG_BLE_MESH_PROXY_FILTER_SIZE];
    enum __packed {
        NONE,
        WHITELIST,
        BLACKLIST,
        PROV,
    } filter_type;
    u8_t msg_type;
    struct net_buf_simple buf;
} servers[BLE_MESH_MAX_CONN];

static u8_t server_buf_data[SERVER_BUF_SIZE * BLE_MESH_MAX_CONN];

static struct bt_mesh_proxy_server *find_server(struct bt_mesh_conn *conn)
{
    int i;

    for (i = 0; i < ARRAY_SIZE(servers); i++) {
        if (servers[i].conn == conn) {
            return &servers[i];
        }
    }

    return NULL;
}

static int filter_status(struct bt_mesh_proxy_server *server,
                         struct net_buf_simple *buf)
{
    /* TODO: Deal with received proxy configuration status messages */
    return 0;
}

#if 0
static void send_filter_set(struct bt_mesh_proxy_server *server,
                            struct bt_mesh_net_rx *rx,
                            struct net_buf_simple *buf)
{
    /* TODO: Act as proxy client, send proxy configuration set messages */
}

static void send_filter_add(struct bt_mesh_proxy_server *server,
                            struct bt_mesh_net_rx *rx,
                            struct net_buf_simple *buf)
{
    /* TODO: Act as proxy client, send proxy configuration add messages */
}

static void send_filter_remove(struct bt_mesh_proxy_server *server,
                               struct bt_mesh_net_rx *rx,
                               struct net_buf_simple *buf)
{
    /* TODO: Act as proxy client, send proxy configuration remove messages */
}
#endif

static void proxy_cfg(struct bt_mesh_proxy_server *server)
{
    NET_BUF_SIMPLE_DEFINE(buf, 29);
    struct bt_mesh_net_rx rx;
    u8_t opcode;
    int err;

    /** In order to deal with proxy configuration messages, provisioner should
     *  do sth. like create mesh network after each device is provisioned.
     */
    err = bt_mesh_net_decode(&server->buf, BLE_MESH_NET_IF_PROXY_CFG,
                             &rx, &buf);
    if (err) {
        BT_ERR("%s, Failed to decode Proxy Configuration (err %d)", __func__, err);
        return;
    }

    /* Remove network headers */
    net_buf_simple_pull(&buf, BLE_MESH_NET_HDR_LEN);

    BT_DBG("%u bytes: %s", buf.len, bt_hex(buf.data, buf.len));

    if (buf.len < 1) {
        BT_WARN("Too short proxy configuration PDU");
        return;
    }

    opcode = net_buf_simple_pull_u8(&buf);
    switch (opcode) {
    case CFG_FILTER_STATUS:
        filter_status(server, &buf);
        break;
    default:
        BT_WARN("Unhandled configuration OpCode 0x%02x", opcode);
        break;
    }
}

static void proxy_complete_pdu(struct bt_mesh_proxy_server *server)
{
    switch (server->msg_type) {
#if defined(CONFIG_BLE_MESH_GATT_PROXY)
    case BLE_MESH_PROXY_NET_PDU:
        BT_DBG("Mesh Network PDU");
        bt_mesh_net_recv(&server->buf, 0, BLE_MESH_NET_IF_PROXY);
        break;
    case BLE_MESH_PROXY_BEACON:
        BT_DBG("Mesh Beacon PDU");
        provisioner_beacon_recv(&server->buf);
        break;
    case BLE_MESH_PROXY_CONFIG:
        BT_DBG("Mesh Configuration PDU");
        proxy_cfg(server);
        break;
#endif
#if defined(CONFIG_BLE_MESH_PB_GATT)
    case BLE_MESH_PROXY_PROV:
        BT_DBG("Mesh Provisioning PDU");
        provisioner_pb_gatt_recv(server->conn, &server->buf);
        break;
#endif
    default:
        BT_WARN("Unhandled Message Type 0x%02x", server->msg_type);
        break;
    }

    net_buf_simple_reset(&server->buf);
}

#define ATTR_IS_PROV(uuid) (uuid == BLE_MESH_UUID_MESH_PROV_VAL)

static ssize_t proxy_recv(struct bt_mesh_conn *conn,
                          const struct bt_mesh_gatt_attr *attr, const void *buf,
                          u16_t len, u16_t offset, u8_t flags)
{
    struct bt_mesh_proxy_server *server = find_server(conn);
    const u8_t *data = buf;
    u16_t srvc_uuid = 0;

    if (!server) {
        return -ENOTCONN;
    }

    if (len < 1) {
        BT_WARN("Too small Proxy PDU");
        return -EINVAL;
    }

    srvc_uuid = bt_mesh_gattc_get_service_uuid(conn);
    if (!srvc_uuid) {
        BT_ERR("%s, No service uuid found", __func__);
        return -ENOTCONN;
    }

    if (ATTR_IS_PROV(srvc_uuid) != (PDU_TYPE(data) == BLE_MESH_PROXY_PROV)) {
        BT_WARN("Proxy PDU type doesn't match GATT service uuid");
        return -EINVAL;
    }

    if (len - 1 > net_buf_simple_tailroom(&server->buf)) {
        BT_WARN("Too big proxy PDU");
        return -EINVAL;
    }

    switch (PDU_SAR(data)) {
    case SAR_COMPLETE:
        if (server->buf.len) {
            BT_WARN("Complete PDU while a pending incomplete one");
            return -EINVAL;
        }

        server->msg_type = PDU_TYPE(data);
        net_buf_simple_add_mem(&server->buf, data + 1, len - 1);
        proxy_complete_pdu(server);
        break;

    case SAR_FIRST:
        if (server->buf.len) {
            BT_WARN("First PDU while a pending incomplete one");
            return -EINVAL;
        }

        server->msg_type = PDU_TYPE(data);
        net_buf_simple_add_mem(&server->buf, data + 1, len - 1);
        break;

    case SAR_CONT:
        if (!server->buf.len) {
            BT_WARN("Continuation with no prior data");
            return -EINVAL;
        }

        if (server->msg_type != PDU_TYPE(data)) {
            BT_WARN("Unexpected message type in continuation");
            return -EINVAL;
        }

        net_buf_simple_add_mem(&server->buf, data + 1, len - 1);
        break;

    case SAR_LAST:
        if (!server->buf.len) {
            BT_WARN("Last SAR PDU with no prior data");
            return -EINVAL;
        }

        if (server->msg_type != PDU_TYPE(data)) {
            BT_WARN("Unexpected message type in last SAR PDU");
            return -EINVAL;
        }

        net_buf_simple_add_mem(&server->buf, data + 1, len - 1);
        proxy_complete_pdu(server);
        break;
    }

    return len;
}

static void proxy_prov_connected(const u8_t addr[6], struct bt_mesh_conn *conn, int id)
{
    struct bt_mesh_proxy_server *server = NULL;

    conn_count++;

    if (!servers[id].conn) {
        server = &servers[id];
    }

    if (!server) {
        BT_ERR("%s, No matching Proxy Client objects", __func__);
        /** Disconnect current connection, clear part of prov_link
         *  information, like uuid, dev_addr, linking flag, etc.
         */

        return;
    }

    server->conn = bt_mesh_conn_ref(conn);
    server->filter_type = NONE;
    memset(server->filter, 0, sizeof(server->filter));
    net_buf_simple_reset(&server->buf);

#if defined(CONFIG_BLE_MESH_PB_GATT)
    if (provisioner_set_prov_conn(addr, server->conn)) {
        BT_ERR("%s, provisioner_set_prov_conn failed", __func__);
        bt_mesh_gattc_disconnect(server->conn);
        return;
    }
#endif

    bt_mesh_gattc_exchange_mtu(id);
}

static void proxy_prov_disconnected(struct bt_mesh_conn *conn, u8_t reason)
{
    struct bt_mesh_proxy_server *server = NULL;
    int i;

    BT_DBG("conn %p, handle is %d, reason 0x%02x", conn, conn->handle, reason);

    if (conn_count) {
        conn_count--;
    }

    for (i = 0; i < ARRAY_SIZE(servers); i++) {
        server = &servers[i];
        if (server->conn == conn) {
            if (IS_ENABLED(CONFIG_BLE_MESH_PB_GATT) &&
                    server->filter_type == PROV) {
                provisioner_pb_gatt_close(conn, reason);
            }
            server->conn = NULL;
            break;
        }
    }
}

#if defined(CONFIG_BLE_MESH_PB_GATT)
static ssize_t prov_write_ccc_descr(struct bt_mesh_conn *conn, u8_t *addr)
{
    struct bt_mesh_proxy_server *server;

    server = find_server(conn);

    if (!server) {
        BT_ERR("%s, No Proxy Server found", __func__);
        return -ENOTCONN;
    }

    if (server->filter_type == NONE) {
        server->filter_type = PROV;
        return provisioner_pb_gatt_open(conn, addr);
    }

    return -EINVAL;
}

static ssize_t prov_notification(struct bt_mesh_conn *conn, u8_t *data, u16_t len)
{
    struct bt_mesh_proxy_server *server;

    server = find_server(conn);

    if (!server) {
        BT_ERR("%s, No Proxy Server found", __func__);
        return -ENOTCONN;
    }

    if (server->filter_type == PROV) {
        return proxy_recv(conn, NULL, data, len, 0, 0);
    }

    return -EINVAL;
}

int provisioner_pb_gatt_enable(void)
{
    int i;

    BT_DBG("%s", __func__);

    for (i = 0; i < ARRAY_SIZE(servers); i++) {
        if (servers[i].conn) {
            servers[i].filter_type = PROV;
        }
    }

    return 0;
}

int provisioner_pb_gatt_disable(void)
{
    int i;

    BT_DBG("%s", __func__);

    for (i = 0; i < ARRAY_SIZE(servers); i++) {
        struct bt_mesh_proxy_server *server = &servers[i];

        if (server->conn && server->filter_type == PROV) {
            bt_mesh_gattc_disconnect(server->conn);
            server->filter_type = NONE;
        }
    }

    return 0;
}

#endif /* CONFIG_BLE_MESH_PB_GATT */

#if defined(CONFIG_BLE_MESH_GATT_PROXY)
static ssize_t proxy_write_ccc_descr(struct bt_mesh_conn *conn)
{
    struct bt_mesh_proxy_server *server;

    server = find_server(conn);

    if (!server) {
        BT_ERR("%s, No Proxy Server found", __func__);
        return -ENOTCONN;
    }

    if (server->filter_type == NONE) {
        server->filter_type = WHITELIST;
        return 0;
    }

    return -EINVAL;
}

static ssize_t proxy_notification(struct bt_mesh_conn *conn, u8_t *data, u16_t len)
{
    return proxy_recv(conn, NULL, data, len, 0, 0);
}

/** Currently provisioner does't need bt_mesh_provisioner_proxy_enable()
 *  and bt_mesh_provisioner_proxy_disable() functions, and once they are
 *  used, provisioner can be enabled to parse node_id_adv and net_id_adv
 *  in order to support proxy client role.
 *  And if gatt_proxy is disabled, provisioner can stop dealing with
 *  these two kinds of connectable advertising packets.
 */
int bt_mesh_provisioner_proxy_enable(void)
{
    int i;

    BT_DBG("%s", __func__);

    for (i = 0; i < ARRAY_SIZE(servers); i++) {
        if (servers[i].conn) {
            servers[i].filter_type = WHITELIST;
        }
    }

    /** TODO: Once at leat one device has been provisioned, provisioner
     *  can be set to allow receiving and parsing node_id & net_id adv
     *  packets, and we may use a global flag to indicate this.
     */

    return 0;
}

static void bt_mesh_proxy_gatt_proxy_disconnect(void)
{
    int i;

    BT_DBG("%s", __func__);

    for (i = 0; i < ARRAY_SIZE(servers); i++) {
        struct bt_mesh_proxy_server *server = &servers[i];

        if (server->conn && (server->filter_type == WHITELIST ||
                             server->filter_type == BLACKLIST)) {
            server->filter_type = NONE;
            bt_mesh_gattc_disconnect(server->conn);
        }
    }
}

int bt_mesh_provisioner_proxy_disable(void)
{
    BT_DBG("%s", __func__);

    /** TODO: Once this function is invoked, provisioner shall stop
     *  receiving and parsing node_id & net_id adv packets, and if
     *  proxy connection exists, we should disconnect it.
     */

    bt_mesh_proxy_gatt_proxy_disconnect();

    return 0;
}

#endif /* CONFIG_BLE_MESH_GATT_PROXY */

static int proxy_send(struct bt_mesh_conn *conn, const void *data, u16_t len)
{
    BT_DBG("%u bytes: %s", len, bt_hex(data, len));

#if defined(CONFIG_BLE_MESH_GATT_PROXY) || defined(CONFIG_BLE_MESH_PB_GATT)
    return bt_mesh_gattc_write_no_rsp(conn, NULL, data, len);
#endif

    return 0;
}

static int proxy_prov_segment_and_send(struct bt_mesh_conn *conn, u8_t type,
                                       struct net_buf_simple *msg)
{
    u16_t mtu;

    if (conn == NULL) {
        BT_ERR("%s, Invalid parameter", __func__);
        return -EINVAL;
    }

    BT_DBG("conn %p type 0x%02x len %u: %s", conn, type, msg->len,
           bt_hex(msg->data, msg->len));

    mtu = bt_mesh_gattc_get_mtu_info(conn);
    if (!mtu) {
        BT_ERR("%s, Conn used to get mtu does not exist", __func__);
        return -ENOTCONN;
    }

    /* ATT_MTU - OpCode (1 byte) - Handle (2 bytes) */
    mtu -= 3;
    if (mtu > msg->len) {
        net_buf_simple_push_u8(msg, PDU_HDR(SAR_COMPLETE, type));
        return proxy_send(conn, msg->data, msg->len);
    }

    net_buf_simple_push_u8(msg, PDU_HDR(SAR_FIRST, type));
    proxy_send(conn, msg->data, mtu);
    net_buf_simple_pull(msg, mtu);

    while (msg->len) {
        if (msg->len + 1 < mtu) {
            net_buf_simple_push_u8(msg, PDU_HDR(SAR_LAST, type));
            proxy_send(conn, msg->data, msg->len);
            break;
        }

        net_buf_simple_push_u8(msg, PDU_HDR(SAR_CONT, type));
        proxy_send(conn, msg->data, mtu);
        net_buf_simple_pull(msg, mtu);
    }

    return 0;
}

int provisioner_proxy_send(struct bt_mesh_conn *conn, u8_t type,
                           struct net_buf_simple *msg)
{
    struct bt_mesh_proxy_server *server = find_server(conn);

    if (!server) {
        BT_ERR("$%s, No Proxy Server found", __func__);
        return -ENOTCONN;
    }

    if ((server->filter_type == PROV) != (type == BLE_MESH_PROXY_PROV)) {
        BT_ERR("%s, Invalid PDU type for Proxy Client", __func__);
        return -EINVAL;
    }

    return proxy_prov_segment_and_send(conn, type, msg);
}

static struct bt_mesh_prov_conn_cb conn_callbacks = {
    .connected = proxy_prov_connected,
    .disconnected = proxy_prov_disconnected,
#if defined(CONFIG_BLE_MESH_PB_GATT)
    .prov_write_descr = prov_write_ccc_descr,
    .prov_notify = prov_notification,
#endif /* CONFIG_BLE_MESH_PB_GATT */
#if defined(CONFIG_BLE_MESH_GATT_PROXY)
    .proxy_write_descr = proxy_write_ccc_descr,
    .proxy_notify = proxy_notification,
#endif /* CONFIG_BLE_MESH_GATT_PROXY */
};

void provisioner_proxy_srv_data_recv(struct net_buf_simple *buf)
{
    /** TODO: Parse node_id_adv or net_id_adv pkts. Currently we
     *  don't support this function, and if realized later, proxy
     *  client need to check if there is server structure left
     *  before create connection with a server.
     *  check conn_count & CONFIG_BLE_MESH_PBG_SAME_TIME
     */
}

int provisioner_proxy_init(void)
{
    int i;

    /* Initialize the server receive buffers */
    for (i = 0; i < ARRAY_SIZE(servers); i++) {
        struct bt_mesh_proxy_server *server = &servers[i];

        server->buf.size = SERVER_BUF_SIZE;
        server->buf.__buf = server_buf_data + (i * SERVER_BUF_SIZE);
    }

    bt_mesh_gattc_conn_cb_register(&conn_callbacks);

    return 0;
}

#endif /* CONFIG_BLE_MESH_PROVISIONER */