/*
 * Copyright (C) 2020 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.
 */

#ifndef CHRE_PLATFORM_USF_USF_HELPER_H_
#define CHRE_PLATFORM_USF_USF_HELPER_H_

#include "chre/core/sensor_type.h"
#include "chre/platform/system_time.h"
#include "chre/util/dynamic_vector.h"
#include "chre/util/unique_ptr.h"

/*
 * Include USF FlatBuffers services header before including other USF
 * FlatBuffers headers.
 */
#include "usf/usf_flatbuffers.h"

#include "usf/error.h"
#include "usf/fbs/usf_msg_sample_root_generated.h"
#include "usf/reffed_ptr.h"
#include "usf/usf_power.h"
#include "usf/usf_sensor.h"
#include "usf/usf_sensor_report.h"
#include "usf/usf_sensor_req.h"
#include "usf/usf_transport_client.h"

namespace chre {

struct SensorInfo {
  //! Used to fill in the chreSensorDataHeader field. If the user of the helper
  //! doesn't care about this field, then it can be set to 0.
  uint32_t sensorHandle;

  //! Sampling ID corresponding to the active subscription to this sensor, if
  //! one exists. 0 otherwise.
  uint32_t samplingId;
};

//! A callback interface for receiving UsfHelper data events and to allow the
//! UsfHelper to ask for information.
class UsfHelperCallbackInterface {
 public:
  //! Invoked from the USF worker thread to provide sensor data events. The
  //! event data format is one of the chreSensorXXXData defined in the CHRE API,
  //! implicitly specified by sensorType.
  virtual void onSensorDataEvent(uint8_t sensorType,
                                 UniquePtr<uint8_t> &&eventData) = 0;

  /**
   * Invoked by the USF Helper to obtain sensor info for a given sensor type.
   *
   * @param sensorType The sensor type for which info should be populated
   * @param sensorInfo Non-null pointer that will be populated with sensor info
   *     if this method is successful
   * @return true if all sensor info was obtained.
   */
  virtual bool getSensorInfo(uint8_t sensorType, SensorInfo *sensorInfo) = 0;

  //! Invoked from the USF worker thread to provide a sensor sampling status
  //! update. All fields are guaranteed to be valid.
  virtual void onSamplingStatusUpdate(
      uint8_t sensorType, const usf::UsfSensorSamplingEvent *update) = 0;

  //! Invoked from the USF worker thread to indicate that flushing the given
  //! sensor has completed.
  virtual void onFlushComplete(usf::UsfErr err, uint32_t requestId,
                               void *cookie) = 0;

  //! Invoked from the USF worker thread to provide a bias update.
  virtual void onBiasUpdate(
      uint8_t sensorType,
      UniquePtr<struct chreSensorThreeAxisData> &&eventData) = 0;

  //! Invoked from the USF worker thread to provide an host wake suspend update.
  virtual void onHostWakeSuspendEvent(bool awake) = 0;
};

//! Class that allows clients of UsfHelper that only want to listen for sensor
//! events to implement only functions that relate to those events.
class SensorEventCallbackInterface : public UsfHelperCallbackInterface {
 public:
  void onSamplingStatusUpdate(
      uint8_t /*sensorType*/,
      const usf::UsfSensorSamplingEvent * /*update*/) override {}

  void onFlushComplete(usf::UsfErr /*err*/, uint32_t /*requestId*/,
                       void * /*cookie*/) override {}

  void onBiasUpdate(
      uint8_t /*sensorType*/,
      UniquePtr<struct chreSensorThreeAxisData> && /*eventData*/) override {}

  void onHostWakeSuspendEvent(bool /*awake*/) override {}
};

//! Default timeout to wait for the USF transport client to return a response
//! to a request
constexpr Nanoseconds kDefaultUsfWaitTimeout = Seconds(5);

/**
 * Helper class used to abstract away most details of communicating with USF.
 */
class UsfHelper {
 public:
  ~UsfHelper();

  //! Maps USF error codes to CHRE error codes.
  static uint8_t usfErrorToChreError(usf::UsfErr err);

  /**
   * Initializes connection to USF.
   *
   * @param callback USF helper callback.
   * @param worker USF worker pointer. If null, a new worker is created.
   */
  void init(UsfHelperCallbackInterface *callback,
            usf::UsfWorker *worker = nullptr);

  /**
   * Retrieves the list of sensors available from USF.
   *
   * @param sensorList Non-null pointer to a UsfVector that will be populated
   *     with all the available sensors from USF.
   * @return true if the list of sensors was retrieved successfully.
   */
  bool getSensorList(
      usf::UsfVector<refcount::reffed_ptr<usf::UsfSensor>> *sensorList);

  /**
   * Starts sampling sensor data from the given sensor.
   *
   * @param request The various parameters needed to issue the request to the
   *     sensor.
   * @param samplingId Non-null pointer that will be filled in with a valid
   *     sampling ID if the request is issued successfully.
   * @return true if the sensor request was issued successfully.
   */
  bool startSampling(usf::UsfStartSamplingReq *request, uint32_t *samplingId);

  /**
   * Reconfigures an existing sensor request.
   *
   * @param request The various parameters needed to issue the request to the
   *     sensor.
   * @return true if the sensor request was reconfigured successfully.
   */
  bool reconfigureSampling(usf::UsfReconfigSamplingReq *request);

  /**
   * Stops an active sensor request.
   *
   * @param request The various parameters needed to issue the request to the
   *     sensor.
   * @return true if the sensor request was stopped successfully.
   */
  bool stopSampling(usf::UsfStopSamplingReq *request);

  /**
   * Registers the helper for sensor sampling status updates from USF for the
   * given sensor.
   *
   * @param sensor The sensor to listen to sampling status updates from.
   * @return true if registration was successful.
   */
  bool registerForStatusUpdates(refcount::reffed_ptr<usf::UsfSensor> &sensor);

  /**
   * Registers the helper for bias updates from USF for the given sensor.
   * This method is not idempotent meaning a call to unregisterForBiasUpdates
   * must be made for the same sensor prior to another call to this method.
   *
   * @param sensor A non-null reffed_ptr to the sensor to listen for bias
   *     updates from.
   * @return true if registration was successful.
   */
  bool registerForBiasUpdates(
      const refcount::reffed_ptr<usf::UsfSensor> &sensor);

  /**
   * Registers the helper for AP power state update from USF.
   *
   * @return true if successful.
   */
  bool registerForApPowerStateUpdates();

  /**
   * Unregisters the helper from bias updates from USF for the given sensor.
   * If not registered, this method is a no-op.
   *
   * @param sensor A non-null reffed_ptr to the sensor to stop listening to bias
   *     updates from.
   */
  void unregisterForBiasUpdates(
      const refcount::reffed_ptr<usf::UsfSensor> &sensor);

  /**
   * Obtains the latest three axis bias received from the given sensor, if
   * available.
   *
   * @param sensor The USF sensor to obtain the latest bias values from.
   * @param bias A non-null pointer that will be filled with the latest bias
   *     values if available.
   * @return true if a bias value was available for the given sensor.
   */
  bool getThreeAxisBias(const refcount::reffed_ptr<usf::UsfSensor> &sensor,
                        struct chreSensorThreeAxisData *bias) const;

  /**
   * Flushes sensor data from the provided sensor asynchronously. Once all data
   * has been flushed, {@link #onFlushCompleteEvent} will be invoked on the
   * callback the helper was initialized with.
   *
   * @param usfSensorHandle The USF handle corresponding to the sensor to flush
   * @param cookie A cookie that will be delivered when the flush has completed
   * @param requestId The ID associated with this flush request, if it was
   *     made successfully
   * @return True if the flush request was successfully sent.
   */
  bool flushAsync(const usf::UsfServerHandle usfSensorHandle, void *cookie,
                  uint32_t *requestId);

  /**
   * Used to process sensor reports delivered through a listener registered with
   * USF.
   *
   * @param event Pointer containing a valid sensor report
   */
  void processSensorReport(const usf::UsfMsgEvent *event);

  /**
   * Used to process a sensor sampling status update delivered through a
   * listener registered with USF.
   *
   * @param update Update containing the latest state from USF.
   */
  void processStatusUpdate(const usf::UsfSensorSamplingEvent *update);

  /**
   * Process the bias update delivered through a listener registered with USF.
   *
   * @param update Update containing latest bias information for a sensor.
   */
  void processBiasUpdate(const usf::UsfSensorTransformConfigEvent *update);

  /**
   * Process the AP power state update delivered through a  listener registered
   * with USF.
   *
   * @param update Update containing the current AP power state.
   */
  void processApPowerStateUpdate(const usf::UsfApPowerStateEvent *update);

 private:
  /**
   * Disconnects from underlying services prior to shutdown
   */
  void deinit();

  /**
   * Sends a synchronous request to USF with any returned data stored in the
   * given callback.
   *
   * @param req Request that should be issued to USF
   * @param callback Helper callback function used to perform the synchronous
   *     request and contains any response message after the method returns
   * @return true if no errors were encountered issuing the request
   */
  bool sendUsfReqSync(usf::UsfReq *req, usf::UsfReqSyncCallback *callback);

  /**
   * Retrieves the response message from the synchronous callback. The memory
   * associated with the message is owned by the callback itself and will be
   * freed upon callback going out of scope.
   *
   * @param callback Synchronous callback previously used in a successful
   *     sendUsfReqSync invocation
   * @param respMsg Variable containing the response message if this method
   *     succeeds
   * @return true if the response message was decoded and verified successfully
   *     and respMsg is valid.
   */
  template <class T>
  bool getRespMsg(usf::UsfReqSyncCallback &callback, const T **respMsg);

  /**
   * Creates a CHRE sensor event from a USF sensor event
   *
   * @param sampleReport Valid decoded USF sensor sample report
   * @param sensorType CHRE sensor type corresponding to the event
   * @param sensorSample Upon success, populated with a valid CHRE sensor event
   * @return true if the USF sensor event corresponds to a valid, active
   *     sampling request and event creation was successful
   */
  bool createSensorEvent(const usf::UsfSensorSampleReport *sampleReport,
                         uint8_t sensorType, UniquePtr<uint8_t> &sensorSample);

  /**
   * Converts a USF bias update event into the chreSensorThreeAxisData format.
   *
   * @param update USF bias update that needs to be converted.
   * @return If successful, contains a populated UniquePtr. Otherwise, the
   *     UniquePtr will be set to nullptr.
   */
  UniquePtr<struct chreSensorThreeAxisData> convertUsfBiasUpdateToData(
      const usf::UsfSensorTransformConfigEvent *update);

  /**
   * Get the index into the calibrated sensor data array for the given sensor
   * type.
   *
   * @param usfSensorType The USF sensor type to obtain the index for.
   * @return The index into the data array for the given sensor type. If the
   *     sensor type isn't present in the array, kNumUsfCalSensors is returned.
   */
  static size_t getCalArrayIndex(const usf::UsfSensorType usfSensorType);

  //! A struct to store a sensor's calibration data.
  struct UsfCalData {
    uint64_t timestamp;
    float bias[3];
    bool hasBias;
  };

  //! The list of calibrated USF sensors supported.
  enum class UsfCalSensor : size_t {
    AccelCal,
    GyroCal,
    MagCal,
    NumCalSensors,
  };

  static constexpr size_t kNumUsfCalSensors =
      static_cast<size_t>(UsfCalSensor::NumCalSensors);

  //! Cal data of all the cal sensors.
  UsfCalData mCalData[kNumUsfCalSensors] = {};

  //! Client used to send messages to USF
  refcount::reffed_ptr<usf::UsfTransportClient> mTransportClient;

  //! UsfWorker used to dispatch messages to CHRE on its own thread
  refcount::reffed_ptr<usf::UsfWorker> mWorker;

  //! All registered USF event listeners.
  DynamicVector<usf::UsfEventListener *> mUsfEventListeners;

  //! Handle to the USF sensor manager
  usf::UsfServerHandle mSensorMgrHandle;

  //! Currently registered callback
  UsfHelperCallbackInterface *mCallback = nullptr;
};

}  // namespace chre

#endif  // CHRE_PLATFORM_USF_USF_HELPER_H_