/***************************************************************************
 *
 * Copyright 2015-2019 BES.
 * All rights reserved. All unpublished rights reserved.
 *
 * No part of this work may be used or reproduced in any form or by any
 * means, or stored in a database or retrieval system, without prior written
 * permission of BES.
 *
 * Use of this work is governed by a license granted by BES.
 * This work contains confidential and proprietary information of
 * BES. which is protected by copyright, trade secret,
 * trademark and other intellectual property rights.
 *
 ****************************************************************************/
#include "app_ble_cmd_handler.h"
#include "app_ble_custom_cmd.h"
#include "apps.h"
#include "bluetooth.h"
#include "cmsis_os.h"
#include "hal_timer.h"
#include "hal_trace.h"
#include "rwapp_config.h"
#include "stdbool.h"
#include "string.h"

#ifdef BTIF_BLE_APP_DATAPATH_SERVER

#define BLE_CUSTOM_CMD_WAITING_RSP_TIMEOUT_COUNT 8

#define BLE_RAW_DATA_XFER_BUF_SIZE 80
/**
 * @brief waiting response timeout supervision data structure
 *
 */
typedef struct {
  uint16_t entryIndex;    /**< The command waiting for the response */
  uint16_t msTillTimeout; /**< run-time timeout left milliseconds */
} BLE_CUSTOM_CMD_WAITING_RSP_SUPERVISOR_T;

/**
 * @brief Custom command handling environment
 *
 */
typedef struct {
  uint8_t isInRawDataXferStage; /**< true if the received data is raw data,
                                                                false if the
                                   received data is in the format of
                                   BLE_CUSTOM_CMD_PAYLOAD_T*/
  uint16_t lengthOfRawDataXferToReceive;
  uint16_t lengthOfReceivedRawDataXfer;
  uint8_t *ptrRawXferDstBuf;
  BLE_RawDataReceived_Handler_t rawDataHandler;
  BLE_CUSTOM_CMD_WAITING_RSP_SUPERVISOR_T
  waitingRspTimeoutInstance[BLE_CUSTOM_CMD_WAITING_RSP_TIMEOUT_COUNT];
  uint32_t lastSysTicks;
  uint8_t timeoutSupervisorCount;
  osTimerId supervisor_timer_id;
  osMutexId mutex;

} BLE_CUSTOM_CMD_ENV_T;

static uint8_t rawDataXferBuf[BLE_RAW_DATA_XFER_BUF_SIZE];
static BLE_CUSTOM_CMD_ENV_T ble_custom_cmd_env;

osMutexDef(app_ble_cmd_mutex);

static void ble_custom_cmd_rsp_supervision_timer_cb(void const *n);
osTimerDef(APP_CUSTOM_CMD_RSP_SUPERVISION_TIMER,
           ble_custom_cmd_rsp_supervision_timer_cb);

static void BLE_remove_waiting_rsp_timeout_supervision(uint16_t entryIndex);

extern void app_datapath_server_send_data_via_notification(uint8_t *ptrData,
                                                           uint32_t length);
extern void app_datapath_server_send_data_via_indication(uint8_t *ptrData,
                                                         uint32_t length);
extern void app_datapath_server_send_data_via_write_command(uint8_t *ptrData,
                                                            uint32_t length);
extern void app_datapath_server_send_data_via_write_request(uint8_t *ptrData,
                                                            uint32_t length);

/**
 * @brief Callback function of the waiting response supervisor timer.
 *
 */
static void ble_custom_cmd_rsp_supervision_timer_cb(void const *n) {
  uint32_t entryIndex =
      ble_custom_cmd_env.waitingRspTimeoutInstance[0].entryIndex;

  BLE_remove_waiting_rsp_timeout_supervision(entryIndex);

  // it means time-out happens before the response is received from the peer
  // device, trigger the response handler
  CUSTOM_COMMAND_PTR_FROM_ENTRY_INDEX(entryIndex)
      ->cmdRspHandler(TIMEOUT_WAITING_RESPONSE, NULL, 0);
}

void BLE_get_response_handler(uint32_t funcCode, uint8_t *ptrParam,
                              uint32_t paramLen) {
  // parameter length check
  if (paramLen > sizeof(BLE_CUSTOM_CMD_RSP_T)) {
    return;
  }

  if (0 == ble_custom_cmd_env.timeoutSupervisorCount) {
    return;
  }

  BLE_CUSTOM_CMD_RSP_T *rsp = (BLE_CUSTOM_CMD_RSP_T *)ptrParam;

  BLE_CUSTOM_CMD_INSTANCE_T *ptCmdInstance =
      BLE_custom_command_get_entry_pointer_from_cmd_code(rsp->cmdCodeToRsp);
  if (NULL == ptCmdInstance) {
    return;
  }

  // remove the function code from the time-out supervision chain
  BLE_remove_waiting_rsp_timeout_supervision(rsp->cmdCodeToRsp);

  // call the response handler
  if (ptCmdInstance->cmdRspHandler) {
    ptCmdInstance->cmdRspHandler(rsp->cmdRetStatus, rsp->rspData,
                                 rsp->rspDataLen);
  }
}

void BLE_control_raw_data_xfer(bool isStartXfer) {
  ble_custom_cmd_env.isInRawDataXferStage = isStartXfer;

  if (true == isStartXfer) {
    ble_custom_cmd_env.lengthOfReceivedRawDataXfer = 0;
    // default configuration, can be customized by BLE_config_raw_data_xfer
    ble_custom_cmd_env.lengthOfRawDataXferToReceive = sizeof(rawDataXferBuf);
    ble_custom_cmd_env.ptrRawXferDstBuf = (uint8_t *)&rawDataXferBuf;
    ble_custom_cmd_env.rawDataHandler = NULL;
  }
}

void BLE_set_raw_data_xfer_received_callback(
    BLE_RawDataReceived_Handler_t callback) {
  ble_custom_cmd_env.rawDataHandler = callback;
}

void BLE_raw_data_xfer_control_handler(uint32_t funcCode, uint8_t *ptrParam,
                                       uint32_t paramLen) {
  bool isStartXfer = false;

  if (OP_START_RAW_DATA_XFER == funcCode) {
    isStartXfer = true;
  }

  BLE_control_raw_data_xfer(isStartXfer);

  BLE_send_response_to_command(funcCode, NO_ERROR, NULL, 0,
                               TRANSMISSION_VIA_NOTIFICATION);
}

void BLE_start_raw_data_xfer_control_rsp_handler(
    BLE_CUSTOM_CMD_RET_STATUS_E retStatus, uint8_t *ptrParam,
    uint32_t paramLen) {
  if (NO_ERROR == retStatus) {
    /**< now the sending data api won't wrap BLE_CUSTOM_CMD_PAYLOAD_T but will
     * directly send the raw data */
    ble_custom_cmd_env.isInRawDataXferStage = true;
  }
}

void BLE_stop_raw_data_xfer_control_rsp_handler(
    BLE_CUSTOM_CMD_RET_STATUS_E retStatus, uint8_t *ptrParam,
    uint32_t paramLen) {
  if (NO_ERROR == retStatus) {
    ble_custom_cmd_env.isInRawDataXferStage = false;
  }
}

/**
 * @brief Refresh the waiting response supervisor list
 *
 */
static void ble_custom_cmd_refresh_supervisor_env(void) {
  // do nothing if no supervisor was added
  if (ble_custom_cmd_env.timeoutSupervisorCount > 0) {
    uint32_t currentTicks = GET_CURRENT_TICKS();
    uint32_t passedTicks;
    if (currentTicks >= ble_custom_cmd_env.lastSysTicks) {
      passedTicks = (currentTicks - ble_custom_cmd_env.lastSysTicks);
    } else {
      passedTicks =
          (hal_sys_timer_get_max() - ble_custom_cmd_env.lastSysTicks + 1) +
          currentTicks;
    }

    uint32_t deltaMs = TICKS_TO_MS(passedTicks);

    BLE_CUSTOM_CMD_WAITING_RSP_SUPERVISOR_T *pRspSupervisor =
        &(ble_custom_cmd_env.waitingRspTimeoutInstance[0]);
    for (uint32_t index = 0; index < ble_custom_cmd_env.timeoutSupervisorCount;
         index++) {
      ASSERT(pRspSupervisor[index].msTillTimeout > deltaMs,
             "the waiting command response supervisor timer is missing!!!, \
				%d ms passed but the ms to trigger is %d",
             deltaMs, pRspSupervisor[index].msTillTimeout);
      pRspSupervisor[index].msTillTimeout -= deltaMs;
    }
  }

  ble_custom_cmd_env.lastSysTicks = GET_CURRENT_TICKS();
}

/**
 * @brief Remove the time-out supervision of waiting response
 *
 * @param entryIndex 	Entry index of the command table
 *
 */
static void BLE_remove_waiting_rsp_timeout_supervision(uint16_t entryIndex) {
  ASSERT(ble_custom_cmd_env.timeoutSupervisorCount > 0,
         "%s The BLE custom command time-out supervisor is already empty!!!",
         __FUNCTION__);

  osMutexWait(ble_custom_cmd_env.mutex, osWaitForever);

  uint32_t index;
  for (index = 0; index < ble_custom_cmd_env.timeoutSupervisorCount; index++) {
    if (ble_custom_cmd_env.waitingRspTimeoutInstance[index].entryIndex ==
        entryIndex) {
      memcpy(&(ble_custom_cmd_env.waitingRspTimeoutInstance[index]),
             &(ble_custom_cmd_env.waitingRspTimeoutInstance[index + 1]),
             (ble_custom_cmd_env.timeoutSupervisorCount - index - 1) *
                 sizeof(BLE_CUSTOM_CMD_WAITING_RSP_SUPERVISOR_T));
      break;
    }
  }

  // cannot find it, directly return
  if (index == ble_custom_cmd_env.timeoutSupervisorCount) {
    goto exit;
  }

  ble_custom_cmd_env.timeoutSupervisorCount--;

  if (ble_custom_cmd_env.timeoutSupervisorCount > 0) {
    // refresh supervisor environment firstly
    ble_custom_cmd_refresh_supervisor_env();

    // start timer, the first entry is the most close one
    osTimerStart(ble_custom_cmd_env.supervisor_timer_id,
                 ble_custom_cmd_env.waitingRspTimeoutInstance[0].msTillTimeout);
  } else {
    // no supervisor, directly stop the timer
    osTimerStop(ble_custom_cmd_env.supervisor_timer_id);
  }

exit:
  osMutexRelease(ble_custom_cmd_env.mutex);
}

/**
 * @brief Add the time-out supervision of waiting response
 *
 * @param entryIndex 	Index of the command entry
 *
 */
static void BLE_add_waiting_rsp_timeout_supervision(uint16_t entryIndex) {
  ASSERT(ble_custom_cmd_env.timeoutSupervisorCount <
             BLE_CUSTOM_CMD_WAITING_RSP_TIMEOUT_COUNT,
         "%s The BLE custom command time-out supervisor is full!!!",
         __FUNCTION__);

  osMutexWait(ble_custom_cmd_env.mutex, osWaitForever);

  // refresh supervisor environment firstly
  ble_custom_cmd_refresh_supervisor_env();

  BLE_CUSTOM_CMD_INSTANCE_T *pInstance =
      CUSTOM_COMMAND_PTR_FROM_ENTRY_INDEX(entryIndex);

  BLE_CUSTOM_CMD_WAITING_RSP_SUPERVISOR_T
  waitingRspTimeoutInstance[BLE_CUSTOM_CMD_WAITING_RSP_TIMEOUT_COUNT];

  uint32_t index = 0, insertedIndex = 0;
  for (index = 0; index < ble_custom_cmd_env.timeoutSupervisorCount; index++) {
    uint32_t msTillTimeout =
        ble_custom_cmd_env.waitingRspTimeoutInstance[index].msTillTimeout;

    // in the order of low to high
    if ((ble_custom_cmd_env.waitingRspTimeoutInstance[index].entryIndex !=
         entryIndex) &&
        (pInstance->timeoutWaitingRspInMs >= msTillTimeout)) {
      waitingRspTimeoutInstance[insertedIndex++] =
          ble_custom_cmd_env.waitingRspTimeoutInstance[index];
    } else if (pInstance->timeoutWaitingRspInMs < msTillTimeout) {
      waitingRspTimeoutInstance[insertedIndex].entryIndex = entryIndex;
      waitingRspTimeoutInstance[insertedIndex].msTillTimeout =
          pInstance->timeoutWaitingRspInMs;

      insertedIndex++;
    }
  }

  // biggest one? then put it at the end of the list
  if (ble_custom_cmd_env.timeoutSupervisorCount == index) {
    waitingRspTimeoutInstance[insertedIndex].entryIndex = entryIndex;
    waitingRspTimeoutInstance[insertedIndex].msTillTimeout =
        pInstance->timeoutWaitingRspInMs;

    insertedIndex++;
  }

  // copy to the global variable
  memcpy((uint8_t *)&(ble_custom_cmd_env.waitingRspTimeoutInstance),
         (uint8_t *)&waitingRspTimeoutInstance,
         insertedIndex * sizeof(BLE_CUSTOM_CMD_WAITING_RSP_SUPERVISOR_T));

  ble_custom_cmd_env.timeoutSupervisorCount = insertedIndex;

  // start timer, the first entry is the most close one
  osTimerStart(ble_custom_cmd_env.supervisor_timer_id,
               ble_custom_cmd_env.waitingRspTimeoutInstance[0].msTillTimeout);

  osMutexRelease(ble_custom_cmd_env.mutex);
}

/**
 * @brief Return the pointer of the received raw data
 *
 * @return uint8_t*	Pointer of the raw data buffer
 */
uint8_t *BLE_custom_command_raw_data_buffer_pointer(void) {
  return ble_custom_cmd_env.ptrRawXferDstBuf;
}

/**
 * @brief Return the size of the received raw data
 *
 * @return uint16_t	Pointer of the raw data buffer
 */
uint16_t BLE_custom_command_received_raw_data_size(void) {
  return ble_custom_cmd_env.lengthOfReceivedRawDataXfer;
}

/**
 * @brief Receive the data from the peer device and parse them
 *
 * @param ptrData 		Pointer of the received data
 * @param dataLength	Length of the received data
 *
 * @return BLE_CUSTOM_CMD_RET_STATUS_E
 */
BLE_CUSTOM_CMD_RET_STATUS_E
BLE_custom_command_receive_data(uint8_t *ptrData, uint32_t dataLength) {
  TRACE(1, "Receive length %d data: ", dataLength);
  DUMP8("0x%02x ", ptrData, dataLength);
  BLE_CUSTOM_CMD_PAYLOAD_T *pPayload = (BLE_CUSTOM_CMD_PAYLOAD_T *)ptrData;

  if ((OP_START_RAW_DATA_XFER == pPayload->cmdCode) ||
      (OP_STOP_RAW_DATA_XFER == pPayload->cmdCode) ||
      (!(ble_custom_cmd_env.isInRawDataXferStage))) {
    // check command code
    if (pPayload->cmdCode >= OP_COMMAND_COUNT) {
      return INVALID_CMD_CODE;
    }

    // check parameter length
    if (pPayload->paramLen > sizeof(pPayload->param)) {
      return PARAMETER_LENGTH_OUT_OF_RANGE;
    }

    BLE_CUSTOM_CMD_INSTANCE_T *pInstance =
        BLE_custom_command_get_entry_pointer_from_cmd_code(pPayload->cmdCode);

    // execute the command handler
    if (!pInstance)
      pInstance->cmdHandler(pPayload->cmdCode, pPayload->param,
                            pPayload->paramLen);
  } else {
    // the payload of the raw data xfer is 2 bytes cmd code + raw data
    if (dataLength < sizeof(pPayload->cmdCode)) {
      return PARAMETER_LENGTH_TOO_SHORT;
    }

    dataLength -= sizeof(pPayload->cmdCode);
    ptrData += sizeof(pPayload->cmdCode);

    if (NULL == ble_custom_cmd_env.rawDataHandler) {
      // default handler

      // save the received raw data into raw data buffer
      uint32_t bytesToSave;
      if ((dataLength + ble_custom_cmd_env.lengthOfReceivedRawDataXfer) >
          ble_custom_cmd_env.lengthOfRawDataXferToReceive) {
        bytesToSave = ble_custom_cmd_env.lengthOfRawDataXferToReceive -
                      ble_custom_cmd_env.lengthOfReceivedRawDataXfer;
      } else {
        bytesToSave = dataLength;
      }
      memcpy(
          (uint8_t *)&ble_custom_cmd_env
              .ptrRawXferDstBuf[ble_custom_cmd_env.lengthOfReceivedRawDataXfer],
          ptrData, bytesToSave);

      ble_custom_cmd_env.lengthOfReceivedRawDataXfer += bytesToSave;
    } else {
      // custom handler that is set by BLE_set_raw_data_xfer_received_callback
      ble_custom_cmd_env.rawDataHandler(ptrData, dataLength);
    }
  }

  return NO_ERROR;
}

static void BLE_send_out_data(BLE_CUSTOM_CMD_TRANSMISSION_PATH_E path,
                              BLE_CUSTOM_CMD_PAYLOAD_T *ptPayLoad) {
  switch (path) {
  case TRANSMISSION_VIA_NOTIFICATION:
    app_datapath_server_send_data_via_notification(
        (uint8_t *)ptPayLoad,
        (uint32_t)(&(((BLE_CUSTOM_CMD_PAYLOAD_T *)0)->param)) +
            ptPayLoad->paramLen);
    break;
  case TRANSMISSION_VIA_INDICATION:
    app_datapath_server_send_data_via_indication(
        (uint8_t *)ptPayLoad,
        (uint32_t)(&(((BLE_CUSTOM_CMD_PAYLOAD_T *)0)->param)) +
            ptPayLoad->paramLen);
    break;
  case TRANSMISSION_VIA_WRITE_CMD:
    app_datapath_server_send_data_via_write_command(
        (uint8_t *)ptPayLoad,
        (uint32_t)(&(((BLE_CUSTOM_CMD_PAYLOAD_T *)0)->param)) +
            ptPayLoad->paramLen);
    break;
  case TRANSMISSION_VIA_WRITE_REQ:
    app_datapath_server_send_data_via_write_request(
        (uint8_t *)ptPayLoad,
        (uint32_t)(&(((BLE_CUSTOM_CMD_PAYLOAD_T *)0)->param)) +
            ptPayLoad->paramLen);
    break;
  default:
    break;
  }
}

/**
 * @brief Send response to the command request
 *
 * @param responsedCmdCode 	Command code of the responsed command request
 * @param returnStatus		Handling result
 * @param rspData 			Pointer of the response data
 * @param rspDataLen		Length of the response data
 * @param path				Path of the data transmission
 *
 * @return BLE_CUSTOM_CMD_RET_STATUS_E
 */
BLE_CUSTOM_CMD_RET_STATUS_E
BLE_send_response_to_command(uint32_t responsedCmdCode,
                             BLE_CUSTOM_CMD_RET_STATUS_E returnStatus,
                             uint8_t *rspData, uint32_t rspDataLen,
                             BLE_CUSTOM_CMD_TRANSMISSION_PATH_E path) {
  // check responsedCmdCode's validity
  if (responsedCmdCode >= OP_COMMAND_COUNT) {
    return INVALID_CMD_CODE;
  }

  BLE_CUSTOM_CMD_PAYLOAD_T payload;

  BLE_CUSTOM_CMD_RSP_T *pResponse = (BLE_CUSTOM_CMD_RSP_T *)&(payload.param);

  // check parameter length
  if (rspDataLen > sizeof(pResponse->rspData)) {
    return PARAMETER_LENGTH_OUT_OF_RANGE;
  }

  pResponse->cmdCodeToRsp = responsedCmdCode;
  pResponse->cmdRetStatus = returnStatus;
  pResponse->rspDataLen = rspDataLen;
  memcpy(pResponse->rspData, rspData, rspDataLen);

  payload.paramLen = 3 * sizeof(uint16_t) + rspDataLen;

  payload.cmdCode = OP_RESPONSE_TO_CMD;

  BLE_send_out_data(path, &payload);

  return NO_ERROR;
}

/**
 * @brief Send the custom command to the peer device
 *
 * @param cmdCode 	Command code
 * @param ptrParam 	Pointer of the output parameter
 * @param paramLen	Length of the output parameter
 * @param path		Path of the data transmission
 *
 * @return BLE_CUSTOM_CMD_RET_STATUS_E
 */
BLE_CUSTOM_CMD_RET_STATUS_E
BLE_send_custom_command(uint32_t cmdCode, uint8_t *ptrParam, uint32_t paramLen,
                        BLE_CUSTOM_CMD_TRANSMISSION_PATH_E path) {
  // check cmdCode's validity
  if (cmdCode >= OP_COMMAND_COUNT) {
    return INVALID_CMD_CODE;
  }

  BLE_CUSTOM_CMD_PAYLOAD_T payload;

  // check parameter length
  if (paramLen > sizeof(payload.param)) {
    return PARAMETER_LENGTH_OUT_OF_RANGE;
  }

  uint16_t entryIndex =
      BLE_custom_command_get_entry_index_from_cmd_code(cmdCode);
  BLE_CUSTOM_CMD_INSTANCE_T *pInstance =
      CUSTOM_COMMAND_PTR_FROM_ENTRY_INDEX(entryIndex);

  // wrap the command payload
  payload.cmdCode = cmdCode;
  payload.paramLen = paramLen;
  memcpy(payload.param, ptrParam, paramLen);

  // send out the data
  BLE_send_out_data(path, &payload);

  // insert into time-out supervison
  if (pInstance->isNeedResponse) {
    BLE_add_waiting_rsp_timeout_supervision(cmdCode);
  }

  return NO_ERROR;
}

BLE_CUSTOM_CMD_INSTANCE_T *
BLE_custom_command_get_entry_pointer_from_cmd_code(uint16_t cmdCode) {
  for (uint32_t index = 0; index < ((uint32_t)__custom_handler_table_end -
                                    (uint32_t)__custom_handler_table_start) /
                                       sizeof(BLE_CUSTOM_CMD_INSTANCE_T);
       index++) {
    if (CUSTOM_COMMAND_PTR_FROM_ENTRY_INDEX(index)->cmdCode == cmdCode) {
      return CUSTOM_COMMAND_PTR_FROM_ENTRY_INDEX(index);
    }
  }

  return NULL;
}

uint16_t BLE_custom_command_get_entry_index_from_cmd_code(uint16_t cmdCode) {
  for (uint32_t index = 0;
       index < (__custom_handler_table_end - __custom_handler_table_start) /
                   sizeof(BLE_CUSTOM_CMD_INSTANCE_T);
       index++) {
    if (CUSTOM_COMMAND_PTR_FROM_ENTRY_INDEX(index)->cmdCode == cmdCode) {
      return index;
    }
  }

  return INVALID_CUSTOM_ENTRY_INDEX;
}

/**
 * @brief Initialize the BLE custom command framework
 *
 */
void BLE_custom_command_init(void) {
  memset((uint8_t *)&ble_custom_cmd_env, 0, sizeof(ble_custom_cmd_env));

  ble_custom_cmd_env.supervisor_timer_id = osTimerCreate(
      osTimer(APP_CUSTOM_CMD_RSP_SUPERVISION_TIMER), osTimerOnce, NULL);

  ble_custom_cmd_env.mutex = osMutexCreate((osMutex(app_ble_cmd_mutex)));
}
#endif