/*
 * Copyright 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.
 */

#define LOG_TAG "bt_shim_scanner"

#include "le_scanning_manager.h"

#include <base/bind.h>
#include <base/threading/thread.h>
#include <hardware/bluetooth.h>
#include <stdio.h>
#include <unordered_set>

#include "btif/include/btif_common.h"
#include "gd/hci/address.h"
#include "gd/hci/le_scanning_manager.h"
#include "gd/storage/device.h"
#include "gd/storage/le_device.h"
#include "gd/storage/storage_module.h"
#include "main/shim/entry.h"
#include "main/shim/helpers.h"
#include "main/shim/shim.h"

#include "advertise_data_parser.h"
#include "stack/btm/btm_int_types.h"

using bluetooth::ToRawAddress;
using bluetooth::ToGdAddress;

extern void btm_ble_process_adv_pkt_cont_for_inquiry(
    uint16_t event_type, uint8_t address_type, const RawAddress& raw_address,
    uint8_t primary_phy, uint8_t secondary_phy, uint8_t advertising_sid,
    int8_t tx_power, int8_t rssi, uint16_t periodic_adv_int,
    std::vector<uint8_t> advertising_data);

extern void btif_dm_update_ble_remote_properties(const RawAddress& bd_addr,
                                                 BD_NAME bd_name,
                                                 tBT_DEVICE_TYPE dev_type);

class BleScannerInterfaceImpl : public BleScannerInterface,
                                public bluetooth::hci::ScanningCallback {
 public:
  ~BleScannerInterfaceImpl() override{};

  void Init() {
    LOG_INFO("init BleScannerInterfaceImpl");
    bluetooth::shim::GetScanning()->RegisterScanningCallback(this);
  }

  /** Registers a scanner with the stack */
  void RegisterScanner(const bluetooth::Uuid& uuid, RegisterCallback) {
    LOG(INFO) << __func__ << " in shim layer";
    auto app_uuid = bluetooth::hci::Uuid::From128BitBE(uuid.To128BitBE());
    bluetooth::shim::GetScanning()->RegisterScanner(app_uuid);
  }

  /** Unregister a scanner from the stack */
  void Unregister(int scanner_id) {
    LOG(INFO) << __func__ << " in shim layer, scanner_id:" << scanner_id;
    bluetooth::shim::GetScanning()->Unregister(scanner_id);
  }

  /** Start or stop LE device scanning */
  void Scan(bool start) {
    LOG(INFO) << __func__ << " in shim layer";
    bluetooth::shim::GetScanning()->Scan(start);
    init_address_cache();
  }

  /** Setup scan filter params */
  void ScanFilterParamSetup(
      uint8_t client_if, uint8_t action, uint8_t filter_index,
      std::unique_ptr<btgatt_filt_param_setup_t> filt_param,
      FilterParamSetupCallback cb) {
    LOG(INFO) << __func__ << " in shim layer";

    auto apcf_action = static_cast<bluetooth::hci::ApcfAction>(action);
    bluetooth::hci::AdvertisingFilterParameter advertising_filter_parameter;

    if (filt_param != nullptr) {
      if (filt_param && filt_param->dely_mode == 1) {
        bluetooth::shim::GetScanning()->TrackAdvertiser(client_if);
      }
      advertising_filter_parameter.feature_selection = filt_param->feat_seln;
      advertising_filter_parameter.list_logic_type =
          filt_param->list_logic_type;
      advertising_filter_parameter.filter_logic_type =
          filt_param->filt_logic_type;
      advertising_filter_parameter.rssi_high_thresh =
          filt_param->rssi_high_thres;
      advertising_filter_parameter.delivery_mode =
          static_cast<bluetooth::hci::DeliveryMode>(filt_param->dely_mode);
      if (filt_param && filt_param->dely_mode == 1) {
        advertising_filter_parameter.onfound_timeout =
            filt_param->found_timeout;
        advertising_filter_parameter.onfound_timeout_cnt =
            filt_param->found_timeout_cnt;
        advertising_filter_parameter.rssi_low_thres =
            filt_param->rssi_low_thres;
        advertising_filter_parameter.onlost_timeout = filt_param->lost_timeout;
        advertising_filter_parameter.num_of_tracking_entries =
            filt_param->num_of_tracking_entries;
      }
    }

    bluetooth::shim::GetScanning()->ScanFilterParameterSetup(
        apcf_action, filter_index, advertising_filter_parameter);
    // TODO refactor callback mechanism
    do_in_jni_thread(FROM_HERE,
                     base::Bind(cb, 0, 0, btm_status_value(BTM_SUCCESS)));
  }

  /** Configure a scan filter condition  */
  void ScanFilterAdd(int filter_index, std::vector<ApcfCommand> filters,
                     FilterConfigCallback cb) {
    LOG(INFO) << __func__ << " in shim layer";
    std::vector<bluetooth::hci::AdvertisingPacketContentFilterCommand>
        new_filters = {};
    for (size_t i = 0; i < filters.size(); i++) {
      bluetooth::hci::AdvertisingPacketContentFilterCommand command{};
      if (!parse_filter_command(command, filters[i])) {
        LOG_ERROR("invalid apcf command");
        return;
      }
      new_filters.push_back(command);
    }
    bluetooth::shim::GetScanning()->ScanFilterAdd(filter_index, new_filters);
    do_in_jni_thread(FROM_HERE,
                     base::Bind(cb, 0, 0, 0, btm_status_value(BTM_SUCCESS)));
  }

  /** Clear all scan filter conditions for specific filter index*/
  void ScanFilterClear(int filter_index, FilterConfigCallback cb) {
    LOG(INFO) << __func__ << " in shim layer";
    // This function doesn't used in java layer
  }

  /** Enable / disable scan filter feature*/
  void ScanFilterEnable(bool enable, EnableCallback cb) {
    LOG(INFO) << __func__ << " in shim layer";
    bluetooth::shim::GetScanning()->ScanFilterEnable(enable);

    uint8_t action = enable ? 1 : 0;
    do_in_jni_thread(FROM_HERE,
                     base::Bind(cb, action, btm_status_value(BTM_SUCCESS)));
  }

  /** Sets the LE scan interval and window in units of N*0.625 msec */
  void SetScanParameters(int scan_interval, int scan_window, Callback cb) {
    LOG(INFO) << __func__ << " in shim layer";
    // use active scan
    auto scan_type = static_cast<bluetooth::hci::LeScanType>(0x01);
    bluetooth::shim::GetScanning()->SetScanParameters(scan_type, scan_interval,
                                                      scan_window);
    do_in_jni_thread(FROM_HERE, base::Bind(cb, 0));
  }

  /* Configure the batchscan storage */
  void BatchscanConfigStorage(int client_if, int batch_scan_full_max,
                              int batch_scan_trunc_max,
                              int batch_scan_notify_threshold, Callback cb) {
    LOG(INFO) << __func__ << " in shim layer";
    bluetooth::shim::GetScanning()->BatchScanConifgStorage(
        batch_scan_full_max, batch_scan_trunc_max, batch_scan_notify_threshold,
        client_if);
    do_in_jni_thread(FROM_HERE, base::Bind(cb, btm_status_value(BTM_SUCCESS)));
  }

  /* Enable batchscan */
  virtual void BatchscanEnable(int scan_mode, int scan_interval,
                               int scan_window, int addr_type, int discard_rule,
                               Callback cb) {
    LOG(INFO) << __func__ << " in shim layer";
    auto batch_scan_mode =
        static_cast<bluetooth::hci::BatchScanMode>(scan_mode);
    auto batch_scan_discard_rule =
        static_cast<bluetooth::hci::BatchScanDiscardRule>(discard_rule);
    bluetooth::shim::GetScanning()->BatchScanEnable(
        batch_scan_mode, scan_window, scan_interval, batch_scan_discard_rule);
    do_in_jni_thread(FROM_HERE, base::Bind(cb, btm_status_value(BTM_SUCCESS)));
  }

  /* Disable batchscan */
  virtual void BatchscanDisable(Callback cb) {
    LOG(INFO) << __func__ << " in shim layer";
    bluetooth::shim::GetScanning()->BatchScanDisable();
    do_in_jni_thread(FROM_HERE, base::Bind(cb, btm_status_value(BTM_SUCCESS)));
  }

  /* Read out batchscan reports */
  void BatchscanReadReports(int client_if, int scan_mode) {
    LOG(INFO) << __func__ << " in shim layer";
    auto batch_scan_mode =
        static_cast<bluetooth::hci::BatchScanMode>(scan_mode);
    auto scanner_id = static_cast<bluetooth::hci::ScannerId>(client_if);
    bluetooth::shim::GetScanning()->BatchScanReadReport(scanner_id,
                                                        batch_scan_mode);
  }

  void StartSync(uint8_t sid, RawAddress address, uint16_t skip,
                 uint16_t timeout, StartSyncCb start_cb, SyncReportCb report_cb,
                 SyncLostCb lost_cb) {
    LOG(INFO) << __func__ << " in shim layer";
    // This function doesn't implement in the old stack
  }

  void StopSync(uint16_t handle) {
    LOG(INFO) << __func__ << " in shim layer";
    // This function doesn't implement in the old stack
  }

  void RegisterCallbacks(ScanningCallbacks* callbacks) {
    LOG(INFO) << __func__ << " in shim layer";
    scanning_callbacks_ = callbacks;
  }

  void OnScannerRegistered(const bluetooth::hci::Uuid app_uuid,
                           bluetooth::hci::ScannerId scanner_id,
                           ScanningStatus status) {
    auto uuid = bluetooth::Uuid::From128BitBE(app_uuid.To128BitBE());
    do_in_jni_thread(FROM_HERE,
                     base::Bind(&ScanningCallbacks::OnScannerRegistered,
                                base::Unretained(scanning_callbacks_), uuid,
                                scanner_id, status));
  }

  void OnScanResult(uint16_t event_type, uint8_t address_type,
                    bluetooth::hci::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) {
    RawAddress raw_address = ToRawAddress(address);

    do_in_jni_thread(
        FROM_HERE,
        base::BindOnce(&BleScannerInterfaceImpl::handle_remote_properties,
                       base::Unretained(this), raw_address, address_type,
                       advertising_data));

    do_in_jni_thread(
        FROM_HERE,
        base::BindOnce(&ScanningCallbacks::OnScanResult,
                       base::Unretained(scanning_callbacks_), event_type,
                       address_type, raw_address, primary_phy, secondary_phy,
                       advertising_sid, tx_power, rssi,
                       periodic_advertising_interval, advertising_data));

    // TODO: Remove when StartInquiry in GD part implemented
    btm_ble_process_adv_pkt_cont_for_inquiry(
        event_type, address_type, raw_address, primary_phy, secondary_phy,
        advertising_sid, tx_power, rssi, periodic_advertising_interval,
        advertising_data);
  }

  void OnTrackAdvFoundLost(bluetooth::hci::AdvertisingFilterOnFoundOnLostInfo
                               on_found_on_lost_info) {
    AdvertisingTrackInfo track_info = {};
    RawAddress raw_address =
        ToRawAddress(on_found_on_lost_info.advertiser_address);
    track_info.advertiser_address = raw_address;
    track_info.advertiser_address_type =
        on_found_on_lost_info.advertiser_address_type;
    track_info.scanner_id = on_found_on_lost_info.scanner_id;
    track_info.filter_index = on_found_on_lost_info.filter_index;
    track_info.advertiser_state = on_found_on_lost_info.advertiser_state;
    track_info.advertiser_info_present =
        static_cast<uint8_t>(on_found_on_lost_info.advertiser_info_present);
    if (on_found_on_lost_info.advertiser_info_present ==
        bluetooth::hci::AdvtInfoPresent::ADVT_INFO_PRESENT) {
      track_info.tx_power = on_found_on_lost_info.tx_power;
      track_info.rssi = on_found_on_lost_info.rssi;
      track_info.time_stamp = on_found_on_lost_info.time_stamp;
      auto adv_data = on_found_on_lost_info.adv_packet;
      track_info.adv_packet_len = (uint8_t)adv_data.size();
      track_info.adv_packet.reserve(adv_data.size());
      track_info.adv_packet.insert(track_info.adv_packet.end(),
                                   adv_data.begin(), adv_data.end());
      auto scan_rsp_data = on_found_on_lost_info.scan_response;
      track_info.scan_response_len = (uint8_t)scan_rsp_data.size();
      track_info.scan_response.reserve(adv_data.size());
      track_info.scan_response.insert(track_info.scan_response.end(),
                                      scan_rsp_data.begin(),
                                      scan_rsp_data.end());
    }
    do_in_jni_thread(
        FROM_HERE,
        base::BindOnce(&ScanningCallbacks::OnTrackAdvFoundLost,
                       base::Unretained(scanning_callbacks_), track_info));
  }

  void OnBatchScanReports(int client_if, int status, int report_format,
                          int num_records, std::vector<uint8_t> data) {
    do_in_jni_thread(
        FROM_HERE,
        base::BindOnce(&ScanningCallbacks::OnBatchScanReports,
                       base::Unretained(scanning_callbacks_), client_if, status,
                       report_format, num_records, data));
  }

  void OnBatchScanThresholdCrossed(int client_if) {
    do_in_jni_thread(
        FROM_HERE,
        base::BindOnce(&ScanningCallbacks::OnBatchScanThresholdCrossed,
                       base::Unretained(scanning_callbacks_), client_if));
  }

  void OnTimeout() {}

  void OnFilterEnable(bluetooth::hci::Enable enable, uint8_t status){};

  void OnFilterParamSetup(uint8_t available_spaces,
                          bluetooth::hci::ApcfAction action, uint8_t status){};

  void OnFilterConfigCallback(bluetooth::hci::ApcfFilterType filter_type,
                              uint8_t available_spaces,
                              bluetooth::hci::ApcfAction action,
                              uint8_t status){};

  ScanningCallbacks* scanning_callbacks_;

 private:
  bool parse_filter_command(
      bluetooth::hci::AdvertisingPacketContentFilterCommand&
          advertising_packet_content_filter_command,
      ApcfCommand apcf_command) {
    advertising_packet_content_filter_command.filter_type =
        static_cast<bluetooth::hci::ApcfFilterType>(apcf_command.type);
    bluetooth::hci::Address address = ToGdAddress(apcf_command.address);
    advertising_packet_content_filter_command.address = address;
    advertising_packet_content_filter_command.application_address_type =
        static_cast<bluetooth::hci::ApcfApplicationAddressType>(
            apcf_command.addr_type);

    if (!apcf_command.uuid.IsEmpty()) {
      uint8_t uuid_len = apcf_command.uuid.GetShortestRepresentationSize();
      switch (uuid_len) {
        case bluetooth::Uuid::kNumBytes16: {
          advertising_packet_content_filter_command.uuid =
              bluetooth::hci::Uuid::From16Bit(apcf_command.uuid.As16Bit());
        } break;
        case bluetooth::Uuid::kNumBytes32: {
          advertising_packet_content_filter_command.uuid =
              bluetooth::hci::Uuid::From32Bit(apcf_command.uuid.As32Bit());
        } break;
        case bluetooth::Uuid::kNumBytes128: {
          advertising_packet_content_filter_command.uuid =
              bluetooth::hci::Uuid::From128BitBE(
                  apcf_command.uuid.To128BitBE());
        } break;
        default:
          LOG_WARN("illegal UUID length %d", (uint16_t)uuid_len);
          return false;
      }
    }

    if (!apcf_command.uuid_mask.IsEmpty()) {
      uint8_t uuid_len = apcf_command.uuid.GetShortestRepresentationSize();
      switch (uuid_len) {
        case bluetooth::Uuid::kNumBytes16: {
          advertising_packet_content_filter_command.uuid_mask =
              bluetooth::hci::Uuid::From16Bit(apcf_command.uuid_mask.As16Bit());
        } break;
        case bluetooth::Uuid::kNumBytes32: {
          advertising_packet_content_filter_command.uuid_mask =
              bluetooth::hci::Uuid::From32Bit(apcf_command.uuid_mask.As32Bit());
        } break;
        case bluetooth::Uuid::kNumBytes128: {
          advertising_packet_content_filter_command.uuid_mask =
              bluetooth::hci::Uuid::From128BitBE(
                  apcf_command.uuid_mask.To128BitBE());
        } break;
        default:
          LOG_WARN("illegal UUID length %d", (uint16_t)uuid_len);
          return false;
      }
    }

    advertising_packet_content_filter_command.name.assign(
        apcf_command.name.begin(), apcf_command.name.end());
    advertising_packet_content_filter_command.company = apcf_command.company;
    advertising_packet_content_filter_command.company_mask =
        apcf_command.company_mask;
    advertising_packet_content_filter_command.data.assign(
        apcf_command.data.begin(), apcf_command.data.end());
    advertising_packet_content_filter_command.data_mask.assign(
        apcf_command.data_mask.begin(), apcf_command.data_mask.end());
    return true;
  }

  void handle_remote_properties(RawAddress bd_addr, tBLE_ADDR_TYPE addr_type,
                                std::vector<uint8_t> advertising_data) {
    // skip anonymous advertisment
    if (addr_type == BLE_ADDR_ANONYMOUS) {
      return;
    }

    auto device_type = bluetooth::hci::DeviceType::LE;
    uint8_t flag_len;
    const uint8_t* p_flag = AdvertiseDataParser::GetFieldByType(
        advertising_data, BTM_BLE_AD_TYPE_FLAG, &flag_len);
    if (p_flag != NULL && flag_len != 0) {
      if ((BTM_BLE_BREDR_NOT_SPT & *p_flag) == 0) {
        device_type = bluetooth::hci::DeviceType::DUAL;
      }
    }

    uint8_t remote_name_len;
    const uint8_t* p_eir_remote_name = AdvertiseDataParser::GetFieldByType(
        advertising_data, BTM_EIR_COMPLETE_LOCAL_NAME_TYPE, &remote_name_len);

    if (p_eir_remote_name == NULL) {
      p_eir_remote_name = AdvertiseDataParser::GetFieldByType(
          advertising_data, BT_EIR_SHORTENED_LOCAL_NAME_TYPE, &remote_name_len);
    }

    // update device name
    if ((addr_type != BLE_ADDR_RANDOM) || (p_eir_remote_name)) {
      if (!find_address_cache(bd_addr)) {
        add_address_cache(bd_addr);

        if (p_eir_remote_name) {
          if (remote_name_len > BD_NAME_LEN + 1 ||
              (remote_name_len == BD_NAME_LEN + 1 &&
               p_eir_remote_name[BD_NAME_LEN] != '\0')) {
            LOG_INFO("%s dropping invalid packet - device name too long: %d",
                     __func__, remote_name_len);
            return;
          }

          bt_bdname_t bdname;
          memcpy(bdname.name, p_eir_remote_name, remote_name_len);
          if (remote_name_len < BD_NAME_LEN + 1)
            bdname.name[remote_name_len] = '\0';

          btif_dm_update_ble_remote_properties(bd_addr, bdname.name,
                                               device_type);
        }
      }
    }
    if (!bluetooth::shim::is_gd_stack_started_up()) {
      LOG_WARN("Gd stack is stopped, return");
      return;
    }
    auto* storage_module = bluetooth::shim::GetStorage();
    bluetooth::hci::Address address = ToGdAddress(bd_addr);

    // update device type
    auto mutation = storage_module->Modify();
    bluetooth::storage::Device device =
        storage_module->GetDeviceByLegacyKey(address);
    mutation.Add(device.SetDeviceType(device_type));
    mutation.Commit();

    // update address type
    auto mutation2 = storage_module->Modify();
    bluetooth::storage::LeDevice le_device = device.Le();
    mutation2.Add(
        le_device.SetAddressType((bluetooth::hci::AddressType)addr_type));
    mutation2.Commit();
  }

  void add_address_cache(const RawAddress& p_bda) {
    // Remove the oldest entries
    while (remote_bdaddr_cache_.size() >= remote_bdaddr_cache_max_size_) {
      const RawAddress& raw_address = remote_bdaddr_cache_ordered_.front();
      remote_bdaddr_cache_.erase(raw_address);
      remote_bdaddr_cache_ordered_.pop();
    }
    remote_bdaddr_cache_.insert(p_bda);
    remote_bdaddr_cache_ordered_.push(p_bda);
  }

  bool find_address_cache(const RawAddress& p_bda) {
    return (remote_bdaddr_cache_.find(p_bda) != remote_bdaddr_cache_.end());
  }

  void init_address_cache(void) {
    remote_bdaddr_cache_.clear();
    remote_bdaddr_cache_ordered_ = {};
  }

  // all access to this variable should be done on the jni thread
  std::set<RawAddress> remote_bdaddr_cache_;
  std::queue<RawAddress> remote_bdaddr_cache_ordered_;
  const size_t remote_bdaddr_cache_max_size_ = 1024;
};

BleScannerInterfaceImpl* bt_le_scanner_instance = nullptr;

BleScannerInterface* bluetooth::shim::get_ble_scanner_instance() {
  if (bt_le_scanner_instance == nullptr) {
    bt_le_scanner_instance = new BleScannerInterfaceImpl();
  }
  return bt_le_scanner_instance;
}

void bluetooth::shim::init_scanning_manager() {
  bt_le_scanner_instance->Init();
}