/*
 * Copyright 2019 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 "hci/facade/le_scanning_manager_facade.h"

#include <bluetooth/log.h>

#include <cstdint>
#include <unordered_map>
#include <utility>

#include "blueberry/facade/hci/le_scanning_manager_facade.grpc.pb.h"
#include "blueberry/facade/hci/le_scanning_manager_facade.pb.h"
#include "common/bidi_queue.h"
#include "common/bind.h"
#include "grpc/grpc_event_queue.h"
#include "hci/le_scanning_manager.h"
#include "os/log.h"
#include "packet/raw_builder.h"

namespace bluetooth {
namespace hci {
namespace facade {

using ::grpc::ServerAsyncResponseWriter;
using ::grpc::ServerAsyncWriter;
using ::grpc::ServerContext;
using ::grpc::ServerWriter;
using ::grpc::Status;

using namespace blueberry::facade::hci;

class LeScanningManagerFacadeService : public LeScanningManagerFacade::Service, ScanningCallback {
 public:
  LeScanningManagerFacadeService(LeScanningManager* le_scanning_manager, os::Handler* facade_handler)
      : le_scanning_manager_(le_scanning_manager), facade_handler_(facade_handler) {
    log::assert_that(
        le_scanning_manager_ != nullptr, "assert failed: le_scanning_manager_ != nullptr");
    log::assert_that(facade_handler_ != nullptr, "assert failed: facade_handler_ != nullptr");
    le_scanning_manager_->RegisterScanningCallback(this);
  }

  ::grpc::Status RegisterScanner(
      ::grpc::ServerContext* /* context */,
      const RegisterScannerRequest* request,
      ::google::protobuf::Empty* /* response */) override {
    uint32_t uuid_raw = request->uuid();
    bluetooth::hci::Uuid uuid = bluetooth::hci::Uuid::From32Bit(uuid_raw);
    le_scanning_manager_->RegisterScanner(uuid);
    return ::grpc::Status::OK;
  }

  ::grpc::Status Unregister(
      ::grpc::ServerContext* /* context */,
      const UnregisterRequest* request,
      ::google::protobuf::Empty* /* response */) override {
    le_scanning_manager_->Unregister(request->scanner_id());
    return ::grpc::Status::OK;
  }

  ::grpc::Status Scan(
      ::grpc::ServerContext* /* context */,
      const ScanRequest* request,
      ::google::protobuf::Empty* /* response */) override {
    le_scanning_manager_->Scan(request->start());
    return ::grpc::Status::OK;
  }

  ::grpc::Status SetScanParameters(
      ::grpc::ServerContext* /* context */,
      const SetScanParametersRequest* request,
      ::google::protobuf::Empty* /* response */) override {
    auto scan_type = static_cast<hci::LeScanType>(request->scan_type());
    le_scanning_manager_->SetScanParameters(
        request->scanner_id(),
        scan_type,
        request->scan_interval(),
        request->scan_window(),
        request->scan_phy());
    return ::grpc::Status::OK;
  }

  ::grpc::Status FetchCallbackEvents(
      ::grpc::ServerContext* context,
      const ::google::protobuf::Empty* /* request */,
      ::grpc::ServerWriter<ScanningCallbackMsg>* writer) override {
    return callback_events_.RunLoop(context, writer);
  }

  ::grpc::Status FetchAdvertisingReports(
      ::grpc::ServerContext* context,
      const ::google::protobuf::Empty* /* request */,
      ::grpc::ServerWriter<AdvertisingReportMsg>* writer) override {
    return advertising_reports_.RunLoop(context, writer);
  }

  void OnScannerRegistered(
      const bluetooth::hci::Uuid app_uuid, ScannerId /* scanner_id */, ScanningStatus status) {
    ScanningCallbackMsg msg;
    msg.set_message_type(ScanningCallbackMsgType::SCANNER_REGISTERED);
    msg.set_status(static_cast<facade::ScanningStatus>(status));
    msg.set_data(app_uuid.As32Bit());
    callback_events_.OnIncomingEvent(msg);
  };

  void OnSetScannerParameterComplete(ScannerId scanner_id, ScanningStatus status) {
    ScanningCallbackMsg msg;
    msg.set_message_type(ScanningCallbackMsgType::SET_SCANNER_PARAMETER_COMPLETE);
    msg.set_status(static_cast<facade::ScanningStatus>(status));
    msg.set_data(static_cast<uint32_t>(scanner_id));
    callback_events_.OnIncomingEvent(msg);
  };

  void OnScanResult(
      uint16_t /* event_type */,
      uint8_t address_type,
      Address address,
      uint8_t /* primary_phy */,
      uint8_t /* secondary_phy */,
      uint8_t /* advertising_sid */,
      int8_t /* tx_power */,
      int8_t rssi,
      uint16_t /* periodic_advertising_interval */,
      std::vector<uint8_t> advertising_data) {
    AdvertisingReportMsg advertising_report_msg;
    std::vector<LeExtendedAdvertisingResponseRaw> advertisements;
    LeExtendedAdvertisingResponseRaw le_extended_advertising_report;
    le_extended_advertising_report.address_type_ = (DirectAdvertisingAddressType)address_type;
    le_extended_advertising_report.address_ = address;
    le_extended_advertising_report.advertising_data_ = advertising_data;
    le_extended_advertising_report.rssi_ = rssi;
    advertisements.push_back(le_extended_advertising_report);

    auto builder = LeExtendedAdvertisingReportRawBuilder::Create(advertisements);
    std::vector<uint8_t> bytes;
    BitInserter bit_inserter(bytes);
    builder->Serialize(bit_inserter);
    advertising_report_msg.set_event(std::string(bytes.begin(), bytes.end()));
    advertising_reports_.OnIncomingEvent(std::move(advertising_report_msg));
  };
  void OnTrackAdvFoundLost(AdvertisingFilterOnFoundOnLostInfo /* on_found_on_lost_info */){};
  void OnBatchScanReports(
      int /* client_if */,
      int /* status */,
      int /* report_format */,
      int /* num_records */,
      std::vector<uint8_t> /* data */){};
  void OnBatchScanThresholdCrossed(int /* client_if */){};
  void OnTimeout(){};
  void OnFilterEnable(Enable /* enable */, uint8_t /* status */){};
  void OnFilterParamSetup(
      uint8_t /* available_spaces */, ApcfAction /* action */, uint8_t /* status */){};
  void OnFilterConfigCallback(
      ApcfFilterType /* filter_type */,
      uint8_t /* available_spaces */,
      ApcfAction /* action */,
      uint8_t /* status */){};

  void OnPeriodicSyncStarted(
      int /* reg_id */,
      uint8_t /* status */,
      uint16_t /* sync_handle */,
      uint8_t /* advertising_sid */,
      AddressWithType /* address_with_type */,
      uint8_t /* phy */,
      uint16_t /* interval */) override {
    log::info("OnPeriodicSyncStarted in LeScanningManagerFacadeService");
  };

  void OnPeriodicSyncReport(
      uint16_t /* sync_handle */,
      int8_t /* tx_power */,
      int8_t /* rssi */,
      uint8_t /* status */,
      std::vector<uint8_t> /* data */) override {
    log::info("OnPeriodicSyncReport in LeScanningManagerFacadeService");
  };

  void OnPeriodicSyncLost(uint16_t /* sync_handle */) override {
    log::info("OnPeriodicSyncLost in LeScanningManagerFacadeService");
  };

  void OnPeriodicSyncTransferred(
      int /* pa_source */, uint8_t /* status */, Address /* address */) override {
    log::info("OnPeriodicSyncTransferred in LeScanningManagerFacadeService");
  };

  void OnBigInfoReport(uint16_t /* sync_handle */, bool /* encrypted */) override {
    log::info("OnBigInfoReport in LeScanningManagerFacadeService");
  };

  LeScanningManager* le_scanning_manager_;
  os::Handler* facade_handler_;
  ::bluetooth::grpc::GrpcEventQueue<AdvertisingReportMsg> advertising_reports_{"advertising reports"};
  ::bluetooth::grpc::GrpcEventQueue<ScanningCallbackMsg> callback_events_{"callback events"};
};

void LeScanningManagerFacadeModule::ListDependencies(ModuleList* list) const {
  ::bluetooth::grpc::GrpcFacadeModule::ListDependencies(list);
  list->add<hci::LeScanningManager>();
}

void LeScanningManagerFacadeModule::Start() {
  ::bluetooth::grpc::GrpcFacadeModule::Start();
  service_ = new LeScanningManagerFacadeService(GetDependency<hci::LeScanningManager>(), GetHandler());
}

void LeScanningManagerFacadeModule::Stop() {
  delete service_;
  ::bluetooth::grpc::GrpcFacadeModule::Stop();
}

::grpc::Service* LeScanningManagerFacadeModule::GetService() const {
  return service_;
}

const ModuleFactory LeScanningManagerFacadeModule::Factory =
    ::bluetooth::ModuleFactory([]() { return new LeScanningManagerFacadeModule(); });

}  // namespace facade
}  // namespace hci
}  // namespace bluetooth