/******************************************************************************
 *
 *  Copyright 2016 The Android Open Source Project
 *  Copyright 2009-2012 Broadcom Corporation
 *
 *  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.
 *
 ******************************************************************************/

/************************************************************************************
 *
 *  Filename:      btif_hd.c
 *
 *  Description:   HID Device Profile Bluetooth Interface
 *
 *
 ***********************************************************************************/
#include <errno.h>
#include <hardware/bluetooth.h>
#include <hardware/bt_hd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define LOG_TAG "BTIF_HD"

#include "bta_api.h"
#include "bta_hd_api.h"
#include "bta_hh_api.h"

#include "btif_common.h"
#include "btif_hd.h"
#include "btif_storage.h"
#include "btif_util.h"

#define BTIF_HD_APP_NAME_LEN 50
#define BTIF_HD_APP_DESCRIPTION_LEN 50
#define BTIF_HD_APP_PROVIDER_LEN 50
#define BTIF_HD_APP_DESCRIPTOR_LEN 2048

#define COD_HID_KEYBOARD 0x0540
#define COD_HID_POINTING 0x0580
#define COD_HID_COMBO 0x05C0
#define COD_HID_MAJOR 0x0500

extern bool bta_dm_check_if_only_hd_connected(const RawAddress& peer_addr);
extern bool check_cod_hid(const RawAddress* remote_bdaddr);
extern void btif_hh_service_registration(bool enable);

/* HD request events */
typedef enum { BTIF_HD_DUMMY_REQ_EVT = 0 } btif_hd_req_evt_t;

btif_hd_cb_t btif_hd_cb;

static bthd_callbacks_t* bt_hd_callbacks = NULL;
static tBTA_HD_APP_INFO app_info;
static tBTA_HD_QOS_INFO in_qos;
static tBTA_HD_QOS_INFO out_qos;

static void intr_data_copy_cb(uint16_t event, char* p_dst, char* p_src) {
  tBTA_HD_INTR_DATA* p_dst_data = (tBTA_HD_INTR_DATA*)p_dst;
  tBTA_HD_INTR_DATA* p_src_data = (tBTA_HD_INTR_DATA*)p_src;
  uint8_t* p_data;

  if (!p_src) return;

  if (event != BTA_HD_INTR_DATA_EVT) return;

  memcpy(p_dst, p_src, sizeof(tBTA_HD_INTR_DATA));

  p_data = ((uint8_t*)p_dst_data) + sizeof(tBTA_HD_INTR_DATA);

  memcpy(p_data, p_src_data->p_data, p_src_data->len);

  p_dst_data->p_data = p_data;
}

static void set_report_copy_cb(uint16_t event, char* p_dst, char* p_src) {
  tBTA_HD_SET_REPORT* p_dst_data = (tBTA_HD_SET_REPORT*)p_dst;
  tBTA_HD_SET_REPORT* p_src_data = (tBTA_HD_SET_REPORT*)p_src;
  uint8_t* p_data;

  if (!p_src) return;

  if (event != BTA_HD_SET_REPORT_EVT) return;

  memcpy(p_dst, p_src, sizeof(tBTA_HD_SET_REPORT));

  p_data = ((uint8_t*)p_dst_data) + sizeof(tBTA_HD_SET_REPORT);

  memcpy(p_data, p_src_data->p_data, p_src_data->len);

  p_dst_data->p_data = p_data;
}

static void btif_hd_free_buf() {
  if (app_info.descriptor.dsc_list) osi_free(app_info.descriptor.dsc_list);
  if (app_info.p_description) osi_free(app_info.p_description);
  if (app_info.p_name) osi_free(app_info.p_name);
  if (app_info.p_provider) osi_free(app_info.p_provider);
  app_info.descriptor.dsc_list = NULL;
  app_info.p_description = NULL;
  app_info.p_name = NULL;
  app_info.p_provider = NULL;
}

/*******************************************************************************
 *
 * Function         btif_hd_remove_device
 *
 * Description      Removes plugged device
 *
 * Returns          void
 *
 ******************************************************************************/
void btif_hd_remove_device(RawAddress bd_addr) {
  BTA_HdRemoveDevice(bd_addr);
  btif_storage_remove_hidd(&bd_addr);
}

/*******************************************************************************
 *
 * Function         btif_hd_upstreams_evt
 *
 * Description      Executes events in btif context
 *
 * Returns          void
 *
 ******************************************************************************/
static void btif_hd_upstreams_evt(uint16_t event, char* p_param) {
  tBTA_HD* p_data = (tBTA_HD*)p_param;

  BTIF_TRACE_API("%s: event=%s", __func__, dump_hd_event(event));

  switch (event) {
    case BTA_HD_ENABLE_EVT:
      BTIF_TRACE_DEBUG("%s: status=%d", __func__, p_data->status);
      if (p_data->status == BTA_HD_OK) {
        btif_storage_load_hidd();
        btif_hd_cb.status = BTIF_HD_ENABLED;
        /* Register the app if not yet registered */
        if (!btif_hd_cb.app_registered) {
          BTA_HdRegisterApp(&app_info, &in_qos, &out_qos);
          btif_hd_free_buf();
        }
      } else {
        btif_hd_cb.status = BTIF_HD_DISABLED;
        BTIF_TRACE_WARNING("Failed to enable BT-HD, status=%d", p_data->status);
      }
      break;

    case BTA_HD_DISABLE_EVT:
      BTIF_TRACE_DEBUG("%s: status=%d", __func__, p_data->status);
      btif_hd_cb.status = BTIF_HD_DISABLED;
      if (btif_hd_cb.service_dereg_active) {
        BTIF_TRACE_WARNING("registering hid host now");
        btif_hh_service_registration(TRUE);
        btif_hd_cb.service_dereg_active = FALSE;
      }
      btif_hd_free_buf();
      if (p_data->status == BTA_HD_OK)
        memset(&btif_hd_cb, 0, sizeof(btif_hd_cb));
      else
        BTIF_TRACE_WARNING("Failed to disable BT-HD, status=%d",
                           p_data->status);
      break;

    case BTA_HD_REGISTER_APP_EVT: {
      RawAddress* addr = (RawAddress*)&p_data->reg_status.bda;

      if (!p_data->reg_status.in_use) {
        addr = NULL;
      }

      btif_hd_cb.app_registered = TRUE;
      HAL_CBACK(bt_hd_callbacks, application_state_cb, addr,
                BTHD_APP_STATE_REGISTERED);
    } break;

    case BTA_HD_UNREGISTER_APP_EVT:
      btif_hd_cb.app_registered = FALSE;
      HAL_CBACK(bt_hd_callbacks, application_state_cb, NULL,
                BTHD_APP_STATE_NOT_REGISTERED);
      if (btif_hd_cb.service_dereg_active) {
        BTIF_TRACE_WARNING("disabling hid device service now");
        btif_hd_free_buf();
        BTA_HdDisable();
      }
      break;

    case BTA_HD_OPEN_EVT: {
      RawAddress* addr = (RawAddress*)&p_data->conn.bda;
      BTIF_TRACE_WARNING(
          "BTA_HD_OPEN_EVT, address (%02x:%02x:%02x:%02x:%02x:%02x)",
          addr->address[0], addr->address[1], addr->address[2],
          addr->address[3], addr->address[4], addr->address[5]);
      /* Check if the connection is from hid host and not hid device */
      if (check_cod_hid(addr)) {
        /* Incoming connection from hid device, reject it */
        BTIF_TRACE_WARNING("remote device is not hid host, disconnecting");
        btif_hd_cb.forced_disc = TRUE;
        BTA_HdDisconnect();
        break;
      }
      btif_storage_set_hidd((RawAddress*)&p_data->conn.bda);

      HAL_CBACK(bt_hd_callbacks, connection_state_cb,
                (RawAddress*)&p_data->conn.bda, BTHD_CONN_STATE_CONNECTED);
    } break;

    case BTA_HD_CLOSE_EVT:
      if (btif_hd_cb.forced_disc) {
        RawAddress* addr = (RawAddress*)&p_data->conn.bda;
        BTIF_TRACE_WARNING("remote device was forcefully disconnected");
        btif_hd_remove_device(*addr);
        btif_hd_cb.forced_disc = FALSE;
        break;
      }
      HAL_CBACK(bt_hd_callbacks, connection_state_cb,
                (RawAddress*)&p_data->conn.bda, BTHD_CONN_STATE_DISCONNECTED);
      break;

    case BTA_HD_GET_REPORT_EVT:
      HAL_CBACK(bt_hd_callbacks, get_report_cb, p_data->get_report.report_type,
                p_data->get_report.report_id, p_data->get_report.buffer_size);
      break;

    case BTA_HD_SET_REPORT_EVT:
      HAL_CBACK(bt_hd_callbacks, set_report_cb, p_data->set_report.report_type,
                p_data->set_report.report_id, p_data->set_report.len,
                p_data->set_report.p_data);
      break;

    case BTA_HD_SET_PROTOCOL_EVT:
      HAL_CBACK(bt_hd_callbacks, set_protocol_cb, p_data->set_protocol);
      break;

    case BTA_HD_INTR_DATA_EVT:
      HAL_CBACK(bt_hd_callbacks, intr_data_cb, p_data->intr_data.report_id,
                p_data->intr_data.len, p_data->intr_data.p_data);
      break;

    case BTA_HD_VC_UNPLUG_EVT:
      HAL_CBACK(bt_hd_callbacks, connection_state_cb,
                (RawAddress*)&p_data->conn.bda, BTHD_CONN_STATE_DISCONNECTED);
      if (bta_dm_check_if_only_hd_connected(p_data->conn.bda)) {
        BTIF_TRACE_DEBUG("%s: Removing bonding as only HID profile connected",
                         __func__);
        BTA_DmRemoveDevice(p_data->conn.bda);
      } else {
        RawAddress* bd_addr = (RawAddress*)&p_data->conn.bda;
        BTIF_TRACE_DEBUG(
            "%s: Only removing HID data as some other profiles "
            "connected",
            __func__);
        btif_hd_remove_device(*bd_addr);
      }
      HAL_CBACK(bt_hd_callbacks, vc_unplug_cb);
      break;

    case BTA_HD_CONN_STATE_EVT:
      HAL_CBACK(bt_hd_callbacks, connection_state_cb,
                (RawAddress*)&p_data->conn.bda,
                (bthd_connection_state_t)p_data->conn.status);
      break;

    default:
      BTIF_TRACE_WARNING("%s: unknown event (%d)", __func__, event);
      break;
  }
}

/*******************************************************************************
 *
 * Function         bte_hd_evt
 *
 * Description      Switches context from BTE to BTIF for all BT-HD events
 *
 * Returns          void
 *
 ******************************************************************************/

static void bte_hd_evt(tBTA_HD_EVT event, tBTA_HD* p_data) {
  bt_status_t status;
  int param_len = 0;
  tBTIF_COPY_CBACK* p_copy_cback = NULL;

  BTIF_TRACE_API("%s event=%d", __func__, event);

  switch (event) {
    case BTA_HD_ENABLE_EVT:
    case BTA_HD_DISABLE_EVT:
    case BTA_HD_UNREGISTER_APP_EVT:
      param_len = sizeof(tBTA_HD_STATUS);
      break;

    case BTA_HD_REGISTER_APP_EVT:
      param_len = sizeof(tBTA_HD_REG_STATUS);
      break;

    case BTA_HD_OPEN_EVT:
    case BTA_HD_CLOSE_EVT:
    case BTA_HD_VC_UNPLUG_EVT:
    case BTA_HD_CONN_STATE_EVT:
      param_len = sizeof(tBTA_HD_CONN);
      break;

    case BTA_HD_GET_REPORT_EVT:
      param_len += sizeof(tBTA_HD_GET_REPORT);
      break;

    case BTA_HD_SET_REPORT_EVT:
      param_len = sizeof(tBTA_HD_SET_REPORT) + p_data->set_report.len;
      p_copy_cback = set_report_copy_cb;
      break;

    case BTA_HD_SET_PROTOCOL_EVT:
      param_len += sizeof(p_data->set_protocol);
      break;

    case BTA_HD_INTR_DATA_EVT:
      param_len = sizeof(tBTA_HD_INTR_DATA) + p_data->intr_data.len;
      p_copy_cback = intr_data_copy_cb;
      break;
  }

  status = btif_transfer_context(btif_hd_upstreams_evt, (uint16_t)event,
                                 (char*)p_data, param_len, p_copy_cback);

  ASSERTC(status == BT_STATUS_SUCCESS, "context transfer failed", status);
}

/*******************************************************************************
 *
 * Function        init
 *
 * Description     Initializes BT-HD interface
 *
 * Returns         BT_STATUS_SUCCESS
 *
 ******************************************************************************/
static bt_status_t init(bthd_callbacks_t* callbacks) {
  BTIF_TRACE_API("%s", __func__);

  bt_hd_callbacks = callbacks;
  memset(&btif_hd_cb, 0, sizeof(btif_hd_cb));

  btif_enable_service(BTA_HIDD_SERVICE_ID);

  return BT_STATUS_SUCCESS;
}

/*******************************************************************************
 *
 * Function         cleanup
 *
 * Description      Cleans up BT-HD interface
 *
 * Returns          none
 *
 ******************************************************************************/
static void cleanup(void) {
  BTIF_TRACE_API("hd:%s", __func__);

  if (bt_hd_callbacks) {
    /* update flag, not to enable hid host service now as BT is switching off */
    btif_hd_cb.service_dereg_active = FALSE;
    btif_disable_service(BTA_HIDD_SERVICE_ID);
    bt_hd_callbacks = NULL;
  }
}

/*******************************************************************************
 *
 * Function         register_app
 *
 * Description      Registers HID Device application
 *
 * Returns          bt_status_t
 *
 ******************************************************************************/
static bt_status_t register_app(bthd_app_param_t* p_app_param,
                                bthd_qos_param_t* p_in_qos,
                                bthd_qos_param_t* p_out_qos) {
  BTIF_TRACE_API("%s", __func__);

  if (btif_hd_cb.app_registered) {
    BTIF_TRACE_WARNING("%s: application already registered", __func__);
    return BT_STATUS_BUSY;
  }

  app_info.p_name = (char*)osi_malloc(BTIF_HD_APP_NAME_LEN);
  memcpy(app_info.p_name, p_app_param->name, BTIF_HD_APP_NAME_LEN);
  app_info.p_description = (char*)osi_malloc(BTIF_HD_APP_DESCRIPTION_LEN);
  memcpy(app_info.p_description, p_app_param->description,
         BTIF_HD_APP_DESCRIPTION_LEN);
  app_info.p_provider = (char*)osi_malloc(BTIF_HD_APP_PROVIDER_LEN);
  memcpy(app_info.p_provider, p_app_param->provider, BTIF_HD_APP_PROVIDER_LEN);
  app_info.subclass = p_app_param->subclass;
  app_info.descriptor.dl_len = p_app_param->desc_list_len;
  app_info.descriptor.dsc_list =
      (uint8_t*)osi_malloc(app_info.descriptor.dl_len);
  memcpy(app_info.descriptor.dsc_list, p_app_param->desc_list,
         p_app_param->desc_list_len);

  in_qos.service_type = p_in_qos->service_type;
  in_qos.token_rate = p_in_qos->token_rate;
  in_qos.token_bucket_size = p_in_qos->token_bucket_size;
  in_qos.peak_bandwidth = p_in_qos->peak_bandwidth;
  in_qos.access_latency = p_in_qos->access_latency;
  in_qos.delay_variation = p_in_qos->delay_variation;

  out_qos.service_type = p_out_qos->service_type;
  out_qos.token_rate = p_out_qos->token_rate;
  out_qos.token_bucket_size = p_out_qos->token_bucket_size;
  out_qos.peak_bandwidth = p_out_qos->peak_bandwidth;
  out_qos.access_latency = p_out_qos->access_latency;
  out_qos.delay_variation = p_out_qos->delay_variation;

  /* register HID Device with L2CAP and unregister HID Host with L2CAP */
  /* Disable HH */
  btif_hh_service_registration(FALSE);

  return BT_STATUS_SUCCESS;
}

/*******************************************************************************
 *
 * Function         unregister_app
 *
 * Description      Unregisters HID Device application
 *
 * Returns          bt_status_t
 *
 ******************************************************************************/
static bt_status_t unregister_app(void) {
  BTIF_TRACE_API("%s", __func__);

  if (!btif_hd_cb.app_registered) {
    BTIF_TRACE_WARNING("%s: application not yet registered", __func__);
    return BT_STATUS_NOT_READY;
  }

  if (btif_hd_cb.status != BTIF_HD_ENABLED) {
    BTIF_TRACE_WARNING("%s: BT-HD not enabled, status=%d", __func__,
                       btif_hd_cb.status);
    return BT_STATUS_NOT_READY;
  }

  if (btif_hd_cb.service_dereg_active) {
    BTIF_TRACE_WARNING("%s: BT-HD deregistering in progress", __func__);
    return BT_STATUS_BUSY;
  }

  btif_hd_cb.service_dereg_active = TRUE;
  BTA_HdUnregisterApp();

  return BT_STATUS_SUCCESS;
}

/*******************************************************************************
 *
 * Function         connect
 *
 * Description      Connects to host
 *
 * Returns          bt_status_t
 *
 ******************************************************************************/
static bt_status_t connect(RawAddress* bd_addr) {
  BTIF_TRACE_API("%s", __func__);

  if (!btif_hd_cb.app_registered) {
    BTIF_TRACE_WARNING("%s: application not yet registered", __func__);
    return BT_STATUS_NOT_READY;
  }

  if (btif_hd_cb.status != BTIF_HD_ENABLED) {
    BTIF_TRACE_WARNING("%s: BT-HD not enabled, status=%d", __func__,
                       btif_hd_cb.status);
    return BT_STATUS_NOT_READY;
  }

  BTA_HdConnect(*bd_addr);

  return BT_STATUS_SUCCESS;
}

/*******************************************************************************
 *
 * Function         disconnect
 *
 * Description      Disconnects from host
 *
 * Returns          bt_status_t
 *
 ******************************************************************************/
static bt_status_t disconnect(void) {
  BTIF_TRACE_API("%s", __func__);

  if (!btif_hd_cb.app_registered) {
    BTIF_TRACE_WARNING("%s: application not yet registered", __func__);
    return BT_STATUS_NOT_READY;
  }

  if (btif_hd_cb.status != BTIF_HD_ENABLED) {
    BTIF_TRACE_WARNING("%s: BT-HD not enabled, status=%d", __func__,
                       btif_hd_cb.status);
    return BT_STATUS_NOT_READY;
  }

  BTA_HdDisconnect();

  return BT_STATUS_SUCCESS;
}

/*******************************************************************************
 *
 * Function         send_report
 *
 * Description      Sends Reports to hid host
 *
 * Returns          bt_status_t
 *
 ******************************************************************************/
static bt_status_t send_report(bthd_report_type_t type, uint8_t id,
                               uint16_t len, uint8_t* p_data) {
  tBTA_HD_REPORT report;

  APPL_TRACE_VERBOSE("%s: type=%d id=%d len=%d", __func__, type, id, len);

  if (!btif_hd_cb.app_registered) {
    BTIF_TRACE_WARNING("%s: application not yet registered", __func__);
    return BT_STATUS_NOT_READY;
  }

  if (btif_hd_cb.status != BTIF_HD_ENABLED) {
    BTIF_TRACE_WARNING("%s: BT-HD not enabled, status=%d", __func__,
                       btif_hd_cb.status);
    return BT_STATUS_NOT_READY;
  }

  if (type == BTHD_REPORT_TYPE_INTRDATA) {
    report.type = BTHD_REPORT_TYPE_INPUT;
    report.use_intr = TRUE;
  } else {
    report.type = (type & 0x03);
    report.use_intr = FALSE;
  }

  report.id = id;
  report.len = len;
  report.p_data = p_data;

  BTA_HdSendReport(&report);

  return BT_STATUS_SUCCESS;
}

/*******************************************************************************
 *
 * Function         report_error
 *
 * Description      Sends HANDSHAKE with error info for invalid SET_REPORT
 *
 * Returns          bt_status_t
 *
 ******************************************************************************/
static bt_status_t report_error(uint8_t error) {
  BTIF_TRACE_API("%s", __func__);

  if (!btif_hd_cb.app_registered) {
    BTIF_TRACE_WARNING("%s: application not yet registered", __func__);
    return BT_STATUS_NOT_READY;
  }

  if (btif_hd_cb.status != BTIF_HD_ENABLED) {
    BTIF_TRACE_WARNING("%s: BT-HD not enabled, status=%d", __func__,
                       btif_hd_cb.status);
    return BT_STATUS_NOT_READY;
  }

  BTA_HdReportError(error);

  return BT_STATUS_SUCCESS;
}

/*******************************************************************************
 *
 * Function         virtual_cable_unplug
 *
 * Description      Sends Virtual Cable Unplug to host
 *
 * Returns          bt_status_t
 *
 ******************************************************************************/
static bt_status_t virtual_cable_unplug(void) {
  BTIF_TRACE_API("%s", __func__);

  if (!btif_hd_cb.app_registered) {
    BTIF_TRACE_WARNING("%s: application not yet registered", __func__);
    return BT_STATUS_NOT_READY;
  }

  if (btif_hd_cb.status != BTIF_HD_ENABLED) {
    BTIF_TRACE_WARNING("%s: BT-HD not enabled, status=%d", __func__,
                       btif_hd_cb.status);
    return BT_STATUS_NOT_READY;
  }

  BTA_HdVirtualCableUnplug();

  return BT_STATUS_SUCCESS;
}

static const bthd_interface_t bthdInterface = {
    sizeof(bthdInterface),
    init,
    cleanup,
    register_app,
    unregister_app,
    connect,
    disconnect,
    send_report,
    report_error,
    virtual_cable_unplug,
};

/*******************************************************************************
 *
 * Function         btif_hd_execute_service
 *
 * Description      Enabled/disables BT-HD service
 *
 * Returns          BT_STATUS_SUCCESS
 *
 ******************************************************************************/
bt_status_t btif_hd_execute_service(bool b_enable) {
  BTIF_TRACE_API("%s: b_enable=%d", __func__, b_enable);

  if (!b_enable) BTA_HdDisable();

  return BT_STATUS_SUCCESS;
}

/*******************************************************************************
 *
 * Function         btif_hd_get_interface
 *
 * Description      Gets BT-HD interface
 *
 * Returns          bthd_interface_t
 *
 ******************************************************************************/
const bthd_interface_t* btif_hd_get_interface() {
  BTIF_TRACE_API("%s", __func__);
  return &bthdInterface;
}

/*******************************************************************************
 *
 * Function         btif_hd_service_registration
 *
 * Description      Registers hid device service
 *
 * Returns          none
 *
 ******************************************************************************/
void btif_hd_service_registration() {
  BTIF_TRACE_API("%s", __func__);
  /* enable HD */
  if (bt_hd_callbacks != NULL) {
    BTA_HdEnable(bte_hd_evt);
  }
}