#include <stdlib.h>
#include <string.h>
#include "aapiGattServer.h"
#include "gatt-builtin.h"
#include "aapiGatt.h"
#include "gatt.h"
#include "log.h"
#include "bt.h"
#include "mt.h"


/* this grouping is not part of the GATT spec and its semantics are thus unclear. */

struct aapiGattServerService {
    int     gattSvc;
    uint8_t inst;
};

struct aapiGattServer {
    struct aapiGattServer         *next;
    struct aapiGattServer         *prev;
    bt_uuid_t                      andrUuid;
    int                            refNum;
    uint32_t                       numServices;
    struct aapiGattServerService  *services;
};


/* our state */
static btgatt_server_callbacks_t mCbks;

static pthread_mutex_t mAapiGattSrvLock = PTHREAD_MUTEX_INITIALIZER;
static struct aapiGattServer *mServers;
static bool mInited = false;


/*
 * FUNCTION: aapiGattServerFindStructByRef
 * USE:      Find a aapiGattServer struct by reference number
 * PARAMS:   ref - the reference
 * RETURN:   the aapiGattServer struct or NULL if not found
 * NOTES:    call with mAapiGattSrvLock held
 */
static struct aapiGattServer* aapiGattServerFindStructByRef(int ref)
{
    struct aapiGattServer *ret = mServers;

    while (ret && ret->refNum != ref)
        ret = ret->next;

    return ret;
}

/*
 * FUNCTION: aapiGattServerFindStructByUuid
 * USE:      Find a aapiGattServer struct by android-style uuid
 * PARAMS:   andrUuid - the uuid
 * RETURN:   the aapiGattServer struct or NULL if not found
 * NOTES:    call with mAapiGattSrvLock held
 */
static struct aapiGattServer* aapiGattServerFindStructByUuid(const bt_uuid_t *andrUuid)
{
    struct aapiGattServer *ret = mServers;

    while (ret && memcmp(&ret->andrUuid, andrUuid, sizeof(ret->andrUuid)))
        ret = ret->next;

    return ret;
}

/*
 * FUNCTION: aapiGattServerContainsServiceWithUuid
 * USE:      See if a aapiGattServer contains a service with a given UUID
 * PARAMS:   srv - the aapiGattServer
 *           uuid - the uuid in question
 *           instIdP - if non-null, instance Id will be stored here
 * RETURN:   true if found, false else
 * NOTES:    call with mAapiGattSrvLock held
 */
static bool aapiGattServerContainsServiceWithUuid(const struct aapiGattServer *srv, const struct uuid *uuid, uint8_t *instIdP)
{
    struct uuid localUuid;
    uint32_t i;

    for (i = 0; i < srv->numServices; i++) {
        if (gattServiceGetUuid(srv->services[i].gattSvc, &localUuid))
            loge("Failed to get uuid. This is not possible\n");
        else if (uuidCmp(&localUuid, uuid)) {
            if (instIdP)
                *instIdP = srv->services[i].inst;
            return true;
        }
    }

    return false;
}

/*
 * FUNCTION: aapiGattServerRegisterServer
 * USE:      Registers a GATT server application with the stack
 * PARAMS:   uuid - the uuid
 * RETURN:   status
 * NOTES:    also calls callback with result if successful result here
 */
static bt_status_t aapiGattServerRegisterServer(bt_uuid_t *andrUuid)
{
    bt_status_t ret = BT_STATUS_FAIL;
    int ref = 0;

    pthread_mutex_lock(&mAapiGattSrvLock);
    if (aapiGattServerFindStructByUuid(andrUuid))
        loge("Refusing to create identical GATT server\n");
    else {
        struct aapiGattServer *srv = (struct aapiGattServer*)calloc(1, sizeof(struct aapiGattServer));
        if (!srv) {
            loge("Failed to allocate GATT server\n");
            ret = BT_STATUS_NOMEM;
        } else {

            /* grab a free reference number */
            srv->refNum = mServers  ? (mServers->refNum + 1) : 1;
            while (aapiGattServerFindStructByRef(srv->refNum))
                srv->refNum++;

            /* link it in */
            srv->next = mServers;
            if (mServers)
                mServers->prev = srv;
            mServers = srv;

            /* save uuid */
            memcpy(&srv->andrUuid, andrUuid, sizeof(srv->andrUuid));

            /* prepare to announce success */
            ret = BT_STATUS_SUCCESS;
            ref = srv->refNum;
        }
    }
    pthread_mutex_unlock(&mAapiGattSrvLock);

    mCbks.register_server_cb(ret, ref, andrUuid);
    return ret;
}

/*
 * FUNCTION: aapiGattServerUnregisterServer
 * USE:      Unregister a server application from the stack
 * PARAMS:   server_if - the server's reference number
 * RETURN:   status
 * NOTES:    also calls callback with result if successful result here
 */
static bt_status_t aapiGattServerUnregisterServer(int server_if)
{
    bt_status_t ret = BT_STATUS_FAIL;
    struct aapiGattServer *srv;

    pthread_mutex_lock(&mAapiGattSrvLock);
    srv = aapiGattServerFindStructByRef(server_if);
    if (!srv)
        logw("Server not found while attempting to unregister\n");
    else {
        uint32_t i;

        if (srv->next)
            srv->next->prev = srv->prev;
        if (srv->prev)
            srv->prev->next = srv->next;
        else
            mServers = srv->next;

        for (i = 0; i < srv->numServices; i++) {
            if (gattServiceIsRunning(srv->services[i].gattSvc)) {
                logw("Unregistering server with running services!\n");
                gattServiceStop(srv->services[i].gattSvc);
            }
            gattServiceDestroy(srv->services[i].gattSvc);
        }
        if (srv->services)
            free(srv->services);
        free(srv);
        ret = BT_STATUS_SUCCESS;
    }
    pthread_mutex_unlock(&mAapiGattSrvLock);

    return ret;
}

/*
 * FUNCTION: aapiGattServerConnect
 * USE:      Create a connection to a remote peripheral
 * PARAMS:   server_if - the server's reference number
 *           bd_addr - remote address
 *           is_direct - XXX: TODO: WTF??
 *           transport - (BT_TRANSPORT_*)
 * RETURN:   status
 * NOTES:    also calls callback with result if successful result here
 */
static bt_status_t aapiGattServerConnect(int server_if, const bt_bdaddr_t *bd_addr, bool is_direct, int transport)
{
    //TODO

    return BT_STATUS_FAIL;
}

/*
 * FUNCTION: aapiGattServerDisconnect
 * USE:      Disconnect an established connection or cancel a pending one
 * PARAMS:   server_if - the server's reference number
 *           bd_addr - remote address
 *           conn_id - connection reference number
 * RETURN:   status
 * NOTES:    also calls callback with result if successful result here
 */
static bt_status_t aapiGattServerDisconnect(int server_if, const bt_bdaddr_t *bd_addr, int conn_id)
{
    //TODO

    return BT_STATUS_FAIL;
}

/*
 * FUNCTION: aapiGattServerReadF
 * USE:      GATT's callback for reading
 * PARAMS:   svc - service ref
 *           who - connection to whom this pertains to
 *           cid - ATT's connection ID
 *           transId - ATT's transaction ID
 *           handle - the handle that this pertains to
 *           byteOfst - the offset into the characteristic for the read (in bytes)
 *           reason - reason for the write (ATT_READ_FOR_*)
 *           wantedLen - the length to write
 * RETURN:   NONE
 * NOTES:    call gattSrvCbkReply() with results. returning false will send ATT_ERROR_UNLIKELY_ERROR to the client
 */
static bool aapiGattServerReadF(int svc, l2c_handle_t who, int cid, int transId, uint16_t handle, uint16_t byteOfst, uint8_t reason, uint16_t len)
{
    struct bt_addr peer;
    bt_bdaddr_t andrPeerAddr;

    if (!l2cApiGetBtAddr(who, &peer)) {
        loge("Failed to get peer addr for read cbk\n");
        return false;
    }

    memcpy(andrPeerAddr.address, peer.addr, sizeof(andrPeerAddr.address));
    mCbks.request_read_cb(cid, transId, &andrPeerAddr, handle, byteOfst, reason == ATT_READ_FOR_READ_BLOB);

    return true;
}

/*
 * FUNCTION: aapiGattServerWriteF
 * USE:      GATT's callback for writing
 * PARAMS:   svc - service ref
 *           who - connection to whom this pertains to
 *           cid - ATT's connection ID
 *           transId - ATT's transaction ID
 *           handle - the handle that this pertains to
 *           byteOfst - the offset into the characteristic for the write (in bytes)
 *           reason - reason for the write (ATT_WRITE_FOR_*)
 *           len - the length to write
 *           data - the data to write
 * RETURN:   NONE
 * NOTES:    call gattSrvCbkReply() with results. returning false will send ATT_ERROR_UNLIKELY_ERROR to the client
 */
static bool aapiGattServerWriteF(int svc, l2c_handle_t who, int cid, int transId, uint16_t handle, uint16_t byteOfst, uint8_t reason, uint16_t len, const void *data)
{
    struct bt_addr peer;
    bt_bdaddr_t andrPeerAddr;

    if (!l2cApiGetBtAddr(who, &peer)) {
        loge("Failed to get peer addr for write cbk\n");
        return false;
    }

    mCbks.request_write_cb(cid, transId, &andrPeerAddr, handle, byteOfst, len, true, reason == ATT_WRITE_FOR_PREPARE, (uint8_t*)data);
    return true;
}

/*
 * FUNCTION: aapiGattServerIndF
 * USE:      GATT's callback for indication/notification progress
 * PARAMS:   svc - service ref
 *           who - connection to whom this pertains to
 *           cid - ATT's connection ID
 *           handle - the handle that this pertains to
 *           evt - what happened (GATT_SRV_EVT_*)
 *           ref - value originally passed to gattServiceSendInd()
 * RETURN:   NONE
 * NOTES:
 */
static void aapiGattServerIndF(int svc, l2c_handle_t who, int cid, uint16_t handle, uint8_t evt, uint64_t ref)
{
    /* XXX: tell java somehow? Current api has no way it seems */
}

/*
 * FUNCTION: aapiGattServerAddService
 * USE:      Create a new service
 * PARAMS:   server_if - the server's reference number
 *           srvc_id - service identifying information
 *           num_handles - how many handles to allocate
 * RETURN:   status
 * NOTES:    also calls callback with result if successful result here
 */
static bt_status_t aapiGattServerAddService(int server_if, btgatt_srvc_id_t *srvc_id, int num_handles)
{
    bt_status_t ret = BT_STATUS_FAIL;
    struct aapiGattServer *srv;
    uint16_t handle = 0;

    pthread_mutex_lock(&mAapiGattSrvLock);
    srv = aapiGattServerFindStructByRef(server_if);
    if (!srv)
        logw("Server not found while attempting to add service\n");
    else {
        struct aapiGattServerService *svcs;
        struct uuid uuid;
        int svc;

        svcs = realloc(srv->services, sizeof(struct aapiGattServerService[srv->numServices + 1]));
	if (!svcs)
            logw("Failed to make space for the service\n");
        else {
            srv->services = svcs;

            aapiGattUuidFromAndroidUuid(&uuid, &srvc_id->id.uuid);
            svc = gattServiceCreate(&uuid, srvc_id->is_primary, num_handles, aapiGattServerReadF, aapiGattServerWriteF, aapiGattServerIndF);
            if (!svc)
                logw("Failed to create GATT service\n");
            else {
                srv->services[srv->numServices].gattSvc = svc;
                srv->services[srv->numServices].inst = srvc_id->id.inst_id;
                srv->numServices++;
                handle = gattServiceGetHandleBaseBySvc(svc);
                ret = BT_STATUS_SUCCESS;
            }
        }
    }
    pthread_mutex_unlock(&mAapiGattSrvLock);

    mCbks.service_added_cb(ret, server_if, srvc_id, handle);
    return ret;
}

/*
 * FUNCTION: aapiGattServerFindService
 * USE:      Find a server and a service given their externally-visible reference numbers
 * PARAMS:   server_if - the server's reference number
 *           service_handle - the handle of the service
 *           srvP - if not NULL, we store the struct aapiGattServer* there
 *           svc - if not NULL, we store the service reference number there
 *           svcIdxInTableP - if not NULL, we store service's index in the server's "services" table
 *           firstOnly - if set handle is service_handle, else it is any handle in the range
 * RETURN:   true if all were found
 * NOTES:    call with mAapiGattSrvLock held
 */
static bool aapiGattServerFindService(int server_if, int handle, struct aapiGattServer **srvP, int *svcP, uint32_t *svcIdxInTableP, bool firstOnly)
{
    struct aapiGattServer *srv;
    uint32_t i;
    int svc;

    srv = aapiGattServerFindStructByRef(server_if);
    if (!srv)
        return false;

    svc = gattServiceFindByHandle(handle, firstOnly);
    if (svc < 0)
        return false;

    /* verify proper belonging */
    for (i = 0; i < srv->numServices; i++)
        if (srv->services[i].gattSvc == svc)
            break;

    if (i == srv->numServices) {
        logw("Found service not aprt of found server!\n");
        return false;
    }

    if (srvP)
        *srvP = srv;

    if (svcP)
        *svcP = svc;

    if (svcIdxInTableP)
        *svcIdxInTableP = i;

    return true;
}

/*
 * FUNCTION: aapiGattServerAddIncludedService
 * USE:      Assign an included service to it's parent service
 * PARAMS:   server_if - the server's reference number
 *           service_handle - the handle of the current service
 *           included_handle - the handle of the included service
 * RETURN:   status
 * NOTES:    also calls callback with result if successful result here
 */
static bt_status_t aapiGattServerAddIncludedService(int server_if, int service_handle, int included_handle)
{
    bt_status_t ret = BT_STATUS_FAIL;
    struct aapiGattServer *srv;
    uint16_t handle = 0;
    int svc;

    pthread_mutex_lock(&mAapiGattSrvLock);
    if (!aapiGattServerFindService(server_if, service_handle, &srv, &svc, NULL, true))
        logw("Server/Service not found while attempting to add included service\n");
    else {
        struct uuid uuid;
        int includedSvc;

        if (!aapiGattServerFindService(server_if, included_handle, NULL, &includedSvc, NULL, true) || !gattServiceGetUuid(includedSvc, &uuid))
            logw("Failed to find or get UUID of included service\n");
        else {

            handle = gattServiceAddIncludedService(svc, &uuid);
            if (handle)
                ret = BT_STATUS_SUCCESS;
        }
    }
    pthread_mutex_unlock(&mAapiGattSrvLock);

    mCbks.included_service_added_cb(ret, server_if, service_handle, handle);
    return ret;
}

/*
 * FUNCTION: aapiGattServerAddCharacteristic
 * USE:      Add a characteristic to a service
 * PARAMS:   server_if - the server's reference number
 *           service_handle - the handle of the current service
 *           andrUuid - the characteristic's UUID in android format
 *           properties - characteristic's properties (in gatt terms)
 *           permissions - characteristic's permissions in android terms
 * RETURN:   status
 * NOTES:    also calls callback with result if successful result here
 */
static bt_status_t aapiGattServerAddCharacteristic(int server_if, int service_handle, bt_uuid_t *andrUuid, int properties, int permissions)
{
    bt_status_t ret = BT_STATUS_FAIL;
    struct aapiGattServer *srv;
    uint16_t handle = 0;
    int svc;

    pthread_mutex_lock(&mAapiGattSrvLock);
    if (!aapiGattServerFindService(server_if, service_handle, &srv, &svc, NULL, true))
        logw("Server/Service not found while attempting to add characteristic\n");
    else {
        struct uuid uuid;

        aapiGattUuidFromAndroidUuid(&uuid, andrUuid);
        handle = gattServiceAddChar(svc, &uuid, properties, permissions);
        if (handle)
            ret = BT_STATUS_SUCCESS;
    }
    pthread_mutex_unlock(&mAapiGattSrvLock);

    mCbks.characteristic_added_cb(ret, server_if, andrUuid, service_handle, handle);
    return ret;
}

/*
 * FUNCTION: aapiGattServerAddDescriptor
 * USE:      Add a descriptor to a given service
 * PARAMS:   server_if - the server's reference number
 *           service_handle - the handle of the current service
 *           andrUuid - the descriptor's UUID in android format
 *           permissions - characteristic's permissions in android terms
 * RETURN:   status
 * NOTES:    also calls callback with result if successful result here
 */
static bt_status_t aapiGattServerAddDescriptor(int server_if, int service_handle, bt_uuid_t *andrUuid, int permissions)
{
    bt_status_t ret = BT_STATUS_FAIL;
    struct aapiGattServer *srv;
    uint16_t handle = 0;
    int svc;

    pthread_mutex_lock(&mAapiGattSrvLock);
    if (!aapiGattServerFindService(server_if, service_handle, &srv, &svc, NULL, true))
        logw("Server/Service not found while attempting to add descriptor\n");
    else {
        struct uuid uuid;

        aapiGattUuidFromAndroidUuid(&uuid, andrUuid);
        handle = gattServiceAddCharDescr(svc, &uuid, permissions);
        if (handle)
            ret = BT_STATUS_SUCCESS;
    }
    pthread_mutex_unlock(&mAapiGattSrvLock);

    mCbks.descriptor_added_cb(ret, server_if, andrUuid, service_handle, handle);
    return ret;
}

/*
 * FUNCTION: aapiGattServerStartService
 * USE:      Starts a local service
 * PARAMS:   server_if - the server's reference number
 *           service_handle - the handle of the current service
 *           transport - which transport to use
 * RETURN:   status
 * NOTES:    also calls callback with result if successful result here
 */
static bt_status_t aapiGattServerStartService(int server_if, int service_handle, int transport)
{
    bt_status_t ret = BT_STATUS_FAIL;
    struct aapiGattServer *srv;
    int svc;

    pthread_mutex_lock(&mAapiGattSrvLock);
    if (!aapiGattServerFindService(server_if, service_handle, &srv, &svc, NULL, true))
        logw("Server/Service not found while attempting to start service\n");
    else {
        bool useLE = transport == GATT_TRANSPORT_LE || transport == GATT_TRANSPORT_LE_BR_EDR;
        bool useEDR = transport == GATT_TRANSPORT_BR_EDR || transport == GATT_TRANSPORT_LE_BR_EDR;

        if (!useLE && !useEDR)
            logw("Cannot bring up service given no transports\n");
        else {

            if (gattServiceStart(svc, useLE, useEDR))
                ret = BT_STATUS_SUCCESS;
        }
    }
    pthread_mutex_unlock(&mAapiGattSrvLock);

    mCbks.service_started_cb(ret, server_if, service_handle);
    return ret;
}

/*
 * FUNCTION: aapiGattServerStopService
 * USE:      Stops a local service
 * PARAMS:   server_if - the server's reference number
 *           service_handle - the handle of the current service
 * RETURN:   status
 * NOTES:    also calls callback with result if successful result here
 */
static bt_status_t aapiGattServerStopService(int server_if, int service_handle)
{
    bt_status_t ret = BT_STATUS_FAIL;
    struct aapiGattServer *srv;
    int svc;

    pthread_mutex_lock(&mAapiGattSrvLock);
    if (!aapiGattServerFindService(server_if, service_handle, &srv, &svc, NULL, true))
        logw("Server/Service not found while attempting to stop service\n");
    else {
       if (gattServiceStop(svc))
            ret = BT_STATUS_SUCCESS;
    }
    pthread_mutex_unlock(&mAapiGattSrvLock);

    mCbks.service_stopped_cb(ret, server_if, service_handle);
    return ret;
}

/*
 * FUNCTION: aapiGattServerDeleteService
 * USE:      Delete a local service
 * PARAMS:   server_if - the server's reference number
 *           service_handle - the handle of the current service
 * RETURN:   status
 * NOTES:    also calls callback with result if successful result here
 */
static bt_status_t aapiGattServerDeleteService(int server_if, int service_handle)
{
    bt_status_t ret = BT_STATUS_FAIL;
    struct aapiGattServer *srv;
    uint32_t idx;
    int svc;

    pthread_mutex_lock(&mAapiGattSrvLock);
    if (!aapiGattServerFindService(server_if, service_handle, &srv, &svc, &idx, true))
        logw("Server/Service not found while attempting to delete service\n");
    else {
       memmove(srv->services + idx, srv->services + srv->numServices - 1, sizeof(struct aapiGattServerService));
       srv->numServices--;
       if (gattServiceDestroy(svc))
           ret = BT_STATUS_SUCCESS;
    }
    pthread_mutex_unlock(&mAapiGattSrvLock);

    mCbks.service_deleted_cb(ret, server_if, service_handle);
    return ret;
}

/*
 * FUNCTION: aapiGattServerSendIndication
 * USE:      Send value indication to a remote device
 * PARAMS:   server_if - the server's reference number
 *           attribute_handle - the handle of the pertinent attribute
 *           conn_id - the connection reference number
 *           len - the length of the data
 *           confirm - need confirmation?
 *           p_value - the value
 * RETURN:   status
 * NOTES:    also calls callback with result if successful result here
 */
static bt_status_t aapiGattServerSendIndication(int server_if, int attribute_handle, int conn_id, int len, int confirm, char *p_value)
{
    bt_status_t ret = BT_STATUS_FAIL;
    struct aapiGattServer *srv;
    int svc;

    pthread_mutex_lock(&mAapiGattSrvLock);
    if (!aapiGattServerFindService(server_if, attribute_handle, &srv, &svc, NULL, false))
        logw("Server/service not found while attempting to send indication\n");
    else {
        if (gattServiceSendInd(svc, conn_id, attribute_handle, p_value, len, !!confirm, 0))
            ret = BT_STATUS_SUCCESS;
    }
    pthread_mutex_unlock(&mAapiGattSrvLock);

    /* XXX: callback here? */
    return ret;
}

/*
 * FUNCTION: aapiGattServerSendResponse
 * USE:      Send a response to a read/write operation
 * PARAMS:   conn_id - the connection reference number
 *           trans_id - transaction reference number
 *           status - the status to send
 *           response - the response to send
 * RETURN:   status
 * NOTES:    also calls callback with result if successful result here
 */
static bt_status_t aapiGattServerSendResponse(int conn_id, int trans_id, int status, btgatt_response_t *response)
{
    gattSrvCbkReply(conn_id, trans_id, response->handle, status, response->attr_value.value, response->attr_value.len);

    return BT_STATUS_SUCCESS;
}

/*
 * FUNCTION: aapiGattServerGetProfileIface
 * USE:      Called to get profile pointer to the GATT server profile
 * PARAMS:   NONE
 * RETURN:   pointer to profile struct
 * NOTES:
 */
void *aapiGattServerGetProfileIface(void)
{
    static const btgatt_server_interface_t iface = {
        .register_server = aapiGattServerRegisterServer,
        .unregister_server = aapiGattServerUnregisterServer,
        .connect = aapiGattServerConnect,
        .disconnect = aapiGattServerDisconnect,
        .add_service = aapiGattServerAddService,
        .add_included_service = aapiGattServerAddIncludedService,
        .add_characteristic = aapiGattServerAddCharacteristic,
        .add_descriptor = aapiGattServerAddDescriptor,
        .start_service = aapiGattServerStartService,
        .stop_service = aapiGattServerStopService,
        .delete_service = aapiGattServerDeleteService,
        .send_indication = aapiGattServerSendIndication,
        .send_response = aapiGattServerSendResponse,
    };

    return (void*)&iface;
}

/*
 * FUNCTION: aapiGattServerInit
 * USE:      Init the GATT server profile
 * PARAMS:   cbks - callbacks back into java
 * RETURN:   status
 * NOTES:
 */
bt_status_t aapiGattServerInit(const btgatt_server_callbacks_t *cbks)
{
    bt_status_t ret;


    memcpy(&mCbks, cbks, sizeof(mCbks));

    pthread_mutex_lock(&mAapiGattSrvLock);
    if (!mInited) {
        if (!attInit()) {
            loge("ATT init failed\n");
        } else if (!gattProfileInit()) {
            attDeinit();
            loge("GATT init failed\n");
        } else if (!gattBuiltinInit()) {
            gattProfileDeinit();
            attDeinit();
            loge("GATT.GAP init failed\n");
        } else
            mInited = true;
    }
    ret = mInited ? BT_STATUS_SUCCESS : BT_STATUS_FAIL;
    pthread_mutex_unlock(&mAapiGattSrvLock);

    return ret;
}

/*
 * FUNCTION: aapiGattServerDeinit
 * USE:      Deinit the GATT server profile
 * PARAMS:   NONE
 * RETURN:   NONE
 * NOTES:
 */
void aapiGattServerDeinit(void)
{
    pthread_mutex_lock(&mAapiGattSrvLock);
    if (mInited) {
        mInited = false;
        gattBuiltinDeinit();
        gattProfileDeinit();
        attDeinit();
    }
    pthread_mutex_unlock(&mAapiGattSrvLock);
}