/*
 * Copyright (C) 2021 The Android Open Source Project
 *
 * 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 "chre/core/ble_request_manager.h"

#include "chre/core/event_loop_manager.h"
#include "chre/platform/fatal_error.h"
#include "chre/platform/log.h"
#include "chre/util/nested_data_ptr.h"

namespace chre {

void BleRequestManager::init() {
  mPlatformBle.init();
}

uint32_t BleRequestManager::getCapabilities() {
  return mPlatformBle.getCapabilities();
}

uint32_t BleRequestManager::getFilterCapabilities() {
  return mPlatformBle.getFilterCapabilities();
}

void BleRequestManager::handleExistingRequest(uint16_t instanceId,
                                              bool *hasExistingRequest,
                                              size_t *requestIndex) {
  const BleRequest *foundRequest =
      mRequests.findRequest(instanceId, requestIndex);
  *hasExistingRequest = (foundRequest != nullptr);
  if (foundRequest != nullptr &&
      foundRequest->getRequestStatus() != RequestStatus::APPLIED) {
    handleAsyncResult(instanceId, foundRequest->isEnabled(),
                      false /* success */, CHRE_ERROR_OBSOLETE_REQUEST,
                      true /* forceUnregister */);
  }
}

bool BleRequestManager::compliesWithBleSetting(uint16_t instanceId,
                                               bool enabled,
                                               bool hasExistingRequest,
                                               size_t requestIndex) {
  bool success = true;
  if (enabled && !bleSettingEnabled()) {
    success = false;
    handleAsyncResult(instanceId, enabled, false /* success */,
                      CHRE_ERROR_FUNCTION_DISABLED);
    if (hasExistingRequest) {
      bool requestChanged = false;
      mRequests.removeRequest(requestIndex, &requestChanged);
    }
  }
  return success;
}

bool BleRequestManager::updateRequests(BleRequest &&request,
                                       bool hasExistingRequest,
                                       bool *requestChanged,
                                       size_t *requestIndex) {
  bool success = true;
  if (hasExistingRequest) {
    mRequests.updateRequest(*requestIndex, std::move(request), requestChanged);
  } else if (request.isEnabled()) {
    success =
        mRequests.addRequest(std::move(request), requestIndex, requestChanged);
  } else {
    // Already disabled requests shouldn't result in work for the PAL.
    *requestChanged = false;
    *requestIndex = mRequests.getRequests().size();
  }
  return success;
}

bool BleRequestManager::startScanAsync(Nanoapp *nanoapp, chreBleScanMode mode,
                                       uint32_t reportDelayMs,
                                       const struct chreBleScanFilter *filter) {
  CHRE_ASSERT(nanoapp);
  BleRequest request(nanoapp->getInstanceId(), true, mode, reportDelayMs,
                     filter);
  return configure(std::move(request));
}

bool BleRequestManager::stopScanAsync(Nanoapp *nanoapp) {
  CHRE_ASSERT(nanoapp);
  BleRequest request(nanoapp->getInstanceId(), false /* enable */);
  return configure(std::move(request));
}

uint32_t BleRequestManager::disableActiveScan(const Nanoapp *nanoapp) {
  CHRE_ASSERT(nanoapp);

  size_t requestIndex;
  const BleRequest *foundRequest =
      mRequests.findRequest(nanoapp->getInstanceId(), &requestIndex);

  if (foundRequest == nullptr || !foundRequest->isEnabled()) {
    // No active request found.
    return 0;
  }

  BleRequest request(nanoapp->getInstanceId(), false /* enable */);
  configure(std::move(request));
  return 1;
}

void BleRequestManager::addBleRequestLog(uint32_t instanceId, bool enabled,
                                         size_t requestIndex,
                                         bool compliesWithBleSetting) {
  BleRequestLog log(SystemTime::getMonotonicTime(), instanceId, enabled,
                    compliesWithBleSetting);
  if (enabled) {
    if (instanceId == CHRE_INSTANCE_ID) {
      log.populateRequestData(mRequests.getCurrentMaximalRequest());
    } else if (compliesWithBleSetting) {
      log.populateRequestData(mRequests.getRequests()[requestIndex]);
    }
  }
  mBleRequestLogs.kick_push(log);
}

bool BleRequestManager::configure(BleRequest &&request) {
  bool success = validateParams(request);
  if (success) {
    bool requestChanged = false;
    size_t requestIndex = 0;
    bool hasExistingRequest = false;
    uint16_t instanceId = request.getInstanceId();
    uint8_t enabled = request.isEnabled();
    handleExistingRequest(instanceId, &hasExistingRequest, &requestIndex);
    bool compliant = compliesWithBleSetting(instanceId, enabled,
                                            hasExistingRequest, requestIndex);
    if (compliant) {
      success = updateRequests(std::move(request), hasExistingRequest,
                               &requestChanged, &requestIndex);
      if (success) {
        if (!asyncResponsePending()) {
          if (!requestChanged) {
            handleAsyncResult(instanceId, enabled, true /* success */,
                              CHRE_ERROR_NONE);
            if (requestIndex < mRequests.getRequests().size()) {
              mRequests.getMutableRequests()[requestIndex].setRequestStatus(
                  RequestStatus::APPLIED);
            }
          } else {
            success = controlPlatform();
            if (!success) {
              handleNanoappEventRegistration(instanceId, enabled,
                                             false /* success */,
                                             true /* forceUnregister */);
              mRequests.removeRequest(requestIndex, &requestChanged);
            }
          }
        }
      }
    }
    if (success) {
      addBleRequestLog(instanceId, enabled, requestIndex, compliant);
    }
  }
  return success;
}

bool BleRequestManager::controlPlatform() {
  bool success = false;
  const BleRequest &maxRequest = mRequests.getCurrentMaximalRequest();
  bool enable = bleSettingEnabled() && maxRequest.isEnabled();
  if (enable) {
    chreBleScanFilter filter = maxRequest.getScanFilter();
    success = mPlatformBle.startScanAsync(
        maxRequest.getMode(), maxRequest.getReportDelayMs(), &filter);
    mPendingPlatformRequest =
        BleRequest(0, enable, maxRequest.getMode(),
                   maxRequest.getReportDelayMs(), &filter);
  } else {
    success = mPlatformBle.stopScanAsync();
    mPendingPlatformRequest = BleRequest(0, enable);
  }
  if (success) {
    for (BleRequest &req : mRequests.getMutableRequests()) {
      if (req.getRequestStatus() == RequestStatus::PENDING_REQ) {
        req.setRequestStatus(RequestStatus::PENDING_RESP);
      }
    }
  }

  return success;
}

void BleRequestManager::handleFreeAdvertisingEvent(
    struct chreBleAdvertisementEvent *event) {
  mPlatformBle.releaseAdvertisingEvent(event);
}

void BleRequestManager::freeAdvertisingEventCallback(uint16_t /* eventType */,
                                                     void *eventData) {
  auto event = static_cast<chreBleAdvertisementEvent *>(eventData);
  EventLoopManagerSingleton::get()
      ->getBleRequestManager()
      .handleFreeAdvertisingEvent(event);
}

void BleRequestManager::handleAdvertisementEvent(
    struct chreBleAdvertisementEvent *event) {
  EventLoopManagerSingleton::get()->getEventLoop().postEventOrDie(
      CHRE_EVENT_BLE_ADVERTISEMENT, event, freeAdvertisingEventCallback);
}

void BleRequestManager::handlePlatformChange(bool enable, uint8_t errorCode) {
  auto callback = [](uint16_t /*type*/, void *data, void *extraData) {
    bool enable = NestedDataPtr<bool>(data);
    uint8_t errorCode = NestedDataPtr<uint8_t>(extraData);
    EventLoopManagerSingleton::get()
        ->getBleRequestManager()
        .handlePlatformChangeSync(enable, errorCode);
  };

  EventLoopManagerSingleton::get()->deferCallback(
      SystemCallbackType::BleScanResponse, NestedDataPtr<bool>(enable),
      callback, NestedDataPtr<uint8_t>(errorCode));
}

void BleRequestManager::handlePlatformChangeSync(bool enable,
                                                 uint8_t errorCode) {
  bool success = (errorCode == CHRE_ERROR_NONE);
  if (mPendingPlatformRequest.isEnabled() != enable) {
    errorCode = CHRE_ERROR;
    success = false;
    CHRE_ASSERT_LOG(false, "BLE PAL did not transition to expected state");
  }
  if (mInternalRequestPending) {
    mInternalRequestPending = false;
    if (!success) {
      FATAL_ERROR("Failed to resync BLE platform");
    }
  } else {
    for (BleRequest &req : mRequests.getMutableRequests()) {
      if (req.getRequestStatus() == RequestStatus::PENDING_RESP) {
        handleAsyncResult(req.getInstanceId(), req.isEnabled(), success,
                          errorCode);
        if (success) {
          req.setRequestStatus(RequestStatus::APPLIED);
        }
      }
    }

    if (!success) {
      mRequests.removeRequests(RequestStatus::PENDING_RESP);
    }
  }
  if (success) {
    // No need to waste memory for requests that have no effect on the overall
    // maximal request.
    mRequests.removeDisabledRequests();
    mActivePlatformRequest = std::move(mPendingPlatformRequest);
  }

  dispatchPendingRequests();

  // Only clear mResyncPending if the request succeeded or after all pending
  // requests are dispatched and a resync request can be issued with only the
  // requests that were previously applied.
  if (mResyncPending) {
    if (success) {
      mResyncPending = false;
    } else if (!success && !asyncResponsePending()) {
      mResyncPending = false;
      updatePlatformRequest(true /* forceUpdate */);
    }
  }
  // Finish dispatching pending requests before processing the setting change
  // request to ensure nanoapps receive CHRE_ERROR_FUNCTION_DISABLED responses.
  // If both a resync and a setting change are pending, prioritize the resync.
  // If the resync successfully completes, the PAL will be in the correct state
  // and updatePlatformRequest will not begin a new request.
  if (mSettingChangePending && !asyncResponsePending()) {
    updatePlatformRequest();
    mSettingChangePending = false;
  }
}

void BleRequestManager::dispatchPendingRequests() {
  if (mRequests.hasRequests(RequestStatus::PENDING_REQ)) {
    uint8_t errorCode = CHRE_ERROR_NONE;
    if (!bleSettingEnabled() && mRequests.isMaximalRequestEnabled()) {
      errorCode = CHRE_ERROR_FUNCTION_DISABLED;
    } else if (!controlPlatform()) {
      errorCode = CHRE_ERROR;
    }
    if (errorCode != CHRE_ERROR_NONE) {
      for (const BleRequest &req : mRequests.getRequests()) {
        if (req.getRequestStatus() == RequestStatus::PENDING_REQ) {
          handleAsyncResult(req.getInstanceId(), req.isEnabled(),
                            false /* success */, errorCode);
        }
      }
      mRequests.removeRequests(RequestStatus::PENDING_REQ);
    }
  }
}

void BleRequestManager::handleAsyncResult(uint16_t instanceId, bool enabled,
                                          bool success, uint8_t errorCode,
                                          bool forceUnregister) {
  uint8_t requestType = enabled ? CHRE_BLE_REQUEST_TYPE_START_SCAN
                                : CHRE_BLE_REQUEST_TYPE_STOP_SCAN;
  postAsyncResultEventFatal(instanceId, requestType, success, errorCode);
  handleNanoappEventRegistration(instanceId, enabled, success, forceUnregister);
}

void BleRequestManager::handleNanoappEventRegistration(uint16_t instanceId,
                                                       bool enabled,
                                                       bool success,
                                                       bool forceUnregister) {
  Nanoapp *nanoapp =
      EventLoopManagerSingleton::get()->getEventLoop().findNanoappByInstanceId(
          instanceId);
  if (nanoapp != nullptr) {
    if (success && enabled) {
      nanoapp->registerForBroadcastEvent(CHRE_EVENT_BLE_ADVERTISEMENT);
    } else if (!enabled || forceUnregister) {
      nanoapp->unregisterForBroadcastEvent(CHRE_EVENT_BLE_ADVERTISEMENT);
    }
  }
}

void BleRequestManager::handleRequestStateResyncCallback() {
  auto callback = [](uint16_t /* eventType */, void * /* eventData */,
                     void * /* extraData */) {
    EventLoopManagerSingleton::get()
        ->getBleRequestManager()
        .handleRequestStateResyncCallbackSync();
  };
  EventLoopManagerSingleton::get()->deferCallback(
      SystemCallbackType::BleRequestResyncEvent, nullptr /* data */, callback);
}

void BleRequestManager::handleRequestStateResyncCallbackSync() {
  if (asyncResponsePending()) {
    mResyncPending = true;
  } else {
    updatePlatformRequest(true /* forceUpdate */);
  }
}

void BleRequestManager::onSettingChanged(Setting setting, bool /* state */) {
  if (setting == Setting::BLE_AVAILABLE) {
    if (asyncResponsePending()) {
      mSettingChangePending = true;
    } else {
      updatePlatformRequest();
    }
  }
}

void BleRequestManager::updatePlatformRequest(bool forceUpdate) {
  bool desiredPlatformState =
      bleSettingEnabled() && mRequests.isMaximalRequestEnabled();
  bool updatePlatform = (forceUpdate || (desiredPlatformState !=
                                         mActivePlatformRequest.isEnabled()));

  if (updatePlatform) {
    if (controlPlatform()) {
      mInternalRequestPending = true;
      addBleRequestLog(CHRE_INSTANCE_ID, desiredPlatformState,
                       mRequests.getRequests().size(),
                       true /* compliesWithBleSetting */);
    } else {
      FATAL_ERROR("Failed to send update BLE platform request");
    }
  }
}

bool BleRequestManager::asyncResponsePending() const {
  return (mInternalRequestPending ||
          mRequests.hasRequests(RequestStatus::PENDING_RESP));
}

bool BleRequestManager::validateParams(const BleRequest &request) {
  bool valid = true;
  if (request.isEnabled()) {
    for (const chreBleGenericFilter &filter : request.getGenericFilters()) {
      if (!isValidAdType(filter.type)) {
        valid = false;
        break;
      }
      if (filter.len == 0 || filter.len > CHRE_BLE_DATA_LEN_MAX) {
        valid = false;
        break;
      }
    }
  }
  return valid;
}

void BleRequestManager::postAsyncResultEventFatal(uint16_t instanceId,
                                                  uint8_t requestType,
                                                  bool success,
                                                  uint8_t errorCode) {
  chreAsyncResult *event = memoryAlloc<chreAsyncResult>();
  if (event == nullptr) {
    FATAL_ERROR("Failed to alloc BLE async result");
  } else {
    event->requestType = requestType;
    event->success = success;
    event->errorCode = errorCode;
    event->reserved = 0;

    EventLoopManagerSingleton::get()->getEventLoop().postEventOrDie(
        CHRE_EVENT_BLE_ASYNC_RESULT, event, freeEventDataCallback, instanceId);
  }
}

bool BleRequestManager::isValidAdType(uint8_t adType) {
  return adType == CHRE_BLE_AD_TYPE_SERVICE_DATA_WITH_UUID_16;
}

bool BleRequestManager::bleSettingEnabled() {
  return EventLoopManagerSingleton::get()
      ->getSettingManager()
      .getSettingEnabled(Setting::BLE_AVAILABLE);
}

void BleRequestManager::logStateToBuffer(DebugDumpWrapper &debugDump) const {
  debugDump.print("\nBLE:\n");
  debugDump.print(" Active Platform Request:\n");
  mActivePlatformRequest.logStateToBuffer(debugDump,
                                          true /* isPlatformRequest */);
  if (asyncResponsePending()) {
    debugDump.print(" Pending Platform Request:\n");
    mPendingPlatformRequest.logStateToBuffer(debugDump,
                                             true /* isPlatformRequest */);
  }
  debugDump.print(" Request Multiplexer:\n");
  for (const BleRequest &req : mRequests.getRequests()) {
    req.logStateToBuffer(debugDump);
  }
  debugDump.print(" Last %zu valid BLE requests:\n", mBleRequestLogs.size());
  static_assert(kNumBleRequestLogs <= INT8_MAX,
                "kNumBleRequestLogs must be less than INT8_MAX.");
  for (int8_t i = static_cast<int8_t>(mBleRequestLogs.size()) - 1; i >= 0;
       i--) {
    const auto &log = mBleRequestLogs[static_cast<size_t>(i)];
    debugDump.print("  ts=%" PRIu64 " instanceId=%" PRIu32 " %s",
                    log.timestamp.toRawNanoseconds(), log.instanceId,
                    log.enable ? "enable" : "disable\n");
    if (log.enable && log.compliesWithBleSetting) {
      debugDump.print(" mode=%" PRIu8 " reportDelayMs=%" PRIu32
                      " rssiThreshold=%" PRId8 " scanCount=%" PRIu8 "\n",
                      log.mode, log.reportDelayMs, log.rssiThreshold,
                      log.scanFilterCount);
    } else if (log.enable) {
      debugDump.print(" request did not comply with BLE setting\n");
    }
  }
}

}  // namespace chre