// Copyright 2018 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "bluetooth/newblued/advertising_manager_interface_handler.h"

#include <memory>
#include <utility>

#include <base/bind.h>
#include <base/callback.h>
#include <base/stl_util.h>
#include <chromeos/dbus/service_constants.h>
#include <dbus/message.h>
#include <dbus/object_path.h>
#include <dbus/object_proxy.h>
#include <dbus/property.h>

#include "bluetooth/newblued/util.h"
#include "bluetooth/newblued/uuid.h"

namespace bluetooth {

class AdvertisementProperties : public dbus::PropertySet {
 public:
  AdvertisementProperties(dbus::ObjectProxy* object_proxy,
                          const base::Callback<bool()>& on_removed)
      : dbus::PropertySet(
            object_proxy,
            bluetooth_advertisement::kBluetoothAdvertisementInterface,
            base::Bind(&AdvertisementProperties::OnChange,
                       base::Unretained(this),
                       on_removed)) {
    RegisterProperty(bluetooth_advertisement::kTypeProperty, &type);
    RegisterProperty(bluetooth_advertisement::kIncludeTxPowerProperty,
                     &include_tx_power);
    RegisterProperty(bluetooth_advertisement::kServiceUUIDsProperty,
                     &service_uuids);
    RegisterProperty(bluetooth_advertisement::kSolicitUUIDsProperty,
                     &solicit_uuids);
    RegisterProperty(bluetooth_advertisement::kManufacturerDataProperty,
                     &manufacturer_data);
    RegisterProperty(bluetooth_advertisement::kServiceDataProperty,
                     &service_data);
  }

  bool Init(brillo::ErrorPtr* error) {
    dbus::MethodCall method_call(dbus::kPropertiesInterface,
                                 dbus::kPropertiesGetAll);
    dbus::MessageWriter writer(&method_call);
    writer.AppendString(interface());
    std::unique_ptr<dbus::Response> response(object_proxy()->CallMethodAndBlock(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
    if (!response) {
      brillo::Error::AddTo(error, FROM_HERE, brillo::errors::dbus::kDomain,
                           bluetooth_advertising_manager::kErrorDoesNotExist,
                           "Advertisement object does not exist");
      return false;
    }

    OnGetAll(response.get());
    return true;
  }

  void OnChange(const base::Callback<bool()>& on_removed,
                const std::string& name) {
    // An advertisement object is considered removed if "Type" is not valid,
    // which is a mandatory property.
    if (name == bluetooth_advertisement::kTypeProperty && !type.is_valid())
      on_removed.Run();
  }

  dbus::Property<std::string> type;
  dbus::Property<bool> include_tx_power;
  dbus::Property<std::vector<std::string>> service_uuids;
  dbus::Property<std::vector<std::string>> solicit_uuids;
  dbus::Property<std::map<uint16_t, std::vector<uint8_t>>> manufacturer_data;
  dbus::Property<std::map<std::string, std::vector<uint8_t>>> service_data;
};

AdvertisingManagerInterfaceHandler::AdvertisingManagerInterfaceHandler(
    LibNewblue* libnewblue,
    scoped_refptr<dbus::Bus> bus,
    ExportedObjectManagerWrapper* exported_object_manager_wrapper)
    : libnewblue_(libnewblue),
      bus_(bus),
      exported_object_manager_wrapper_(exported_object_manager_wrapper) {}

void AdvertisingManagerInterfaceHandler::Init() {
  dbus::ObjectPath adapter_object_path(kAdapterObjectPath);
  exported_object_manager_wrapper_->AddExportedInterface(
      adapter_object_path,
      bluetooth_advertising_manager::kBluetoothAdvertisingManagerInterface,
      base::Bind(&ExportedObjectManagerWrapper::SetupStandardPropertyHandlers));
  ExportedInterface* advertising_manager_interface =
      exported_object_manager_wrapper_->GetExportedInterface(
          adapter_object_path,
          bluetooth_advertising_manager::kBluetoothAdvertisingManagerInterface);

  advertising_manager_interface
      ->EnsureExportedPropertyRegistered<bool>(
          bluetooth_advertising_manager::kIsTXPowerSupportedProperty)
      ->SetValue(libnewblue_->HciAdvIsPowerLevelSettingSupported());
  advertising_manager_interface->AddSimpleMethodHandlerWithErrorAndMessage(
      bluetooth_advertising_manager::kRegisterAdvertisement,
      base::Unretained(this),
      &AdvertisingManagerInterfaceHandler::HandleRegisterAdvertisement);
  advertising_manager_interface->AddSimpleMethodHandlerWithErrorAndMessage(
      bluetooth_advertising_manager::kUnregisterAdvertisement,
      base::Unretained(this),
      &AdvertisingManagerInterfaceHandler::HandleUnregisterAdvertisement);
  advertising_manager_interface->ExportAndBlock();
}

bool AdvertisingManagerInterfaceHandler::HandleRegisterAdvertisement(
    brillo::ErrorPtr* error,
    dbus::Message* message,
    dbus::ObjectPath object_path,
    brillo::VariantDictionary options) {
  if (base::Contains(handles_, object_path)) {
    brillo::Error::AddTo(error, FROM_HERE, brillo::errors::dbus::kDomain,
                         bluetooth_advertising_manager::kErrorAlreadyExists,
                         "Advertisement already registered");
    return false;
  }

  hci_adv_set_t handle = libnewblue_->HciAdvSetAllocate();
  if (!handle) {
    brillo::Error::AddTo(error, FROM_HERE, brillo::errors::dbus::kDomain,
                         bluetooth_advertising_manager::kErrorFailed,
                         "Cannot allocate advertisement handle");
    return false;
  }

  AdvertisementProperties properties(
      bus_->GetObjectProxy(message->GetSender(), object_path),
      base::Bind(
          &AdvertisingManagerInterfaceHandler::HandleUnregisterAdvertisement,
          base::Unretained(this), nullptr, nullptr, object_path));
  std::vector<uint8_t> data;
  if (!properties.Init(error) || !ConstructData(properties, &data, error) ||
      !ConfigureData(handle, data, error) || !SetParams(handle, error) ||
      !Enable(handle, error)) {
    libnewblue_->HciAdvSetFree(handle);
    return false;
  }

  handles_[object_path] = handle;
  return true;
}

bool AdvertisingManagerInterfaceHandler::HandleUnregisterAdvertisement(
    brillo::ErrorPtr* error,
    dbus::Message* message,
    dbus::ObjectPath object_path) {
  auto it = handles_.find(object_path);
  if (it == handles_.end()) {
    brillo::Error::AddTo(error, FROM_HERE, brillo::errors::dbus::kDomain,
                         bluetooth_advertising_manager::kErrorDoesNotExist,
                         "Advertisement not registered");
    return false;
  }

  libnewblue_->HciAdvSetDisable(it->second);
  libnewblue_->HciAdvSetFree(it->second);
  handles_.erase(it);
  return true;
}

bool AdvertisingManagerInterfaceHandler::AddType(const std::string& type,
                                                 std::vector<uint8_t>* data,
                                                 brillo::ErrorPtr* error) {
  constexpr uint8_t kGeneralDiscoverable = 2;
  if (type == bluetooth_advertisement::kTypeBroadcast)
    return true;

  if (type == bluetooth_advertisement::kTypePeripheral) {
    data->push_back(2);
    data->push_back(HCI_EIR_TYPE_FLAGS);
    data->push_back(kGeneralDiscoverable);
    return true;
  }

  brillo::Error::AddTo(error, FROM_HERE, brillo::errors::dbus::kDomain,
                       bluetooth_advertising_manager::kErrorInvalidArguments,
                       "Advertisement type invalid");
  return false;
}

bool AdvertisingManagerInterfaceHandler::AddIncludeTxPower(
    bool include_tx_power,
    std::vector<uint8_t>* data,
    brillo::ErrorPtr* error) {
  if (!include_tx_power)
    return true;

  data->push_back(2);
  data->push_back(HCI_EIR_TX_POWER_LEVEL);
  data->push_back(HCI_ADV_TX_PWR_LVL_DONT_CARE);
  return true;
}

bool AdvertisingManagerInterfaceHandler::AddServiceUuid(
    const std::vector<std::string>& service_uuids,
    std::vector<uint8_t>* data,
    brillo::ErrorPtr* error) {
  for (const std::string& service_uuid : service_uuids) {
    Uuid uuid(service_uuid);
    if (uuid.format() == UuidFormat::UUID_INVALID) {
      brillo::Error::AddTo(
          error, FROM_HERE, brillo::errors::dbus::kDomain,
          bluetooth_advertising_manager::kErrorInvalidArguments,
          "Service uuid invalid");
      return false;
    }

    data->push_back(kUuid128Size + 1);
    data->push_back(HCI_EIR_TYPE_COMPL_LIST_UUID128);
    data->insert(data->end(), uuid.value().rbegin(), uuid.value().rend());
  }
  return true;
}

bool AdvertisingManagerInterfaceHandler::AddSolicitUuid(
    const std::vector<std::string>& solicit_uuids,
    std::vector<uint8_t>* data,
    brillo::ErrorPtr* error) {
  for (const std::string& solicit_uuid : solicit_uuids) {
    Uuid uuid(solicit_uuid);
    if (uuid.format() == UuidFormat::UUID_INVALID) {
      brillo::Error::AddTo(
          error, FROM_HERE, brillo::errors::dbus::kDomain,
          bluetooth_advertising_manager::kErrorInvalidArguments,
          "Solicit uuid invalid");
      return false;
    }

    data->push_back(kUuid128Size + 1);
    data->push_back(HCI_EIR_SVC_SOLICITS_UUID128);
    data->insert(data->end(), uuid.value().rbegin(), uuid.value().rend());
  }
  return true;
}

bool AdvertisingManagerInterfaceHandler::AddServiceData(
    const std::map<std::string, std::vector<uint8_t>>& service_data,
    std::vector<uint8_t>* data,
    brillo::ErrorPtr* error) {
  for (const auto& uuid_data : service_data) {
    Uuid uuid(uuid_data.first);
    if (uuid.format() == UuidFormat::UUID_INVALID) {
      brillo::Error::AddTo(
          error, FROM_HERE, brillo::errors::dbus::kDomain,
          bluetooth_advertising_manager::kErrorInvalidArguments,
          "Service data uuid invalid");
      return false;
    }

    size_t length = uuid_data.second.size() + kUuid128Size + 1;
    if (length > UINT8_MAX) {
      brillo::Error::AddTo(error, FROM_HERE, brillo::errors::dbus::kDomain,
                           bluetooth_advertising_manager::kErrorInvalidLength,
                           "Service data too long");
      return false;
    }

    data->push_back(length);
    data->push_back(HCI_EIR_SVC_DATA_UUID128);
    data->insert(data->end(), uuid.value().rbegin(), uuid.value().rend());
    data->insert(data->end(), uuid_data.second.rbegin(),
                 uuid_data.second.rend());
  }
  return true;
}

bool AdvertisingManagerInterfaceHandler::AddManufacturerData(
    const std::map<uint16_t, std::vector<uint8_t>>& manufacturer_data,
    std::vector<uint8_t>* data,
    brillo::ErrorPtr* error) {
  for (const auto& id_data : manufacturer_data) {
    size_t length = id_data.second.size() + sizeof(uint16_t) + 1;
    if (length > UINT8_MAX) {
      brillo::Error::AddTo(error, FROM_HERE, brillo::errors::dbus::kDomain,
                           bluetooth_advertising_manager::kErrorInvalidLength,
                           "Manufacturer data too long");
      return false;
    }

    data->push_back(length);
    data->push_back(HCI_EIR_MANUF_DATA);
    data->push_back(id_data.first & 0xff);
    data->push_back(id_data.first >> 8);
    data->insert(data->end(), id_data.second.rbegin(), id_data.second.rend());
  }
  return true;
}

bool AdvertisingManagerInterfaceHandler::ConstructData(
    const AdvertisementProperties& properties,
    std::vector<uint8_t>* data,
    brillo::ErrorPtr* error) {
  return AddType(properties.type.value(), data, error) &&
         AddIncludeTxPower(properties.include_tx_power.value(), data, error) &&
         AddServiceUuid(properties.service_uuids.value(), data, error) &&
         AddSolicitUuid(properties.solicit_uuids.value(), data, error) &&
         AddServiceData(properties.service_data.value(), data, error) &&
         AddManufacturerData(properties.manufacturer_data.value(), data, error);
}

bool AdvertisingManagerInterfaceHandler::ConfigureData(
    hci_adv_set_t handle,
    const std::vector<uint8_t>& data,
    brillo::ErrorPtr* error) {
  if (!libnewblue_->HciAdvSetConfigureData(handle, false, data.data(),
                                           data.size())) {
    brillo::Error::AddTo(error, FROM_HERE, brillo::errors::dbus::kDomain,
                         bluetooth_advertising_manager::kErrorFailed,
                         "Cannot configure data");
    return false;
  }

  return true;
}

bool AdvertisingManagerInterfaceHandler::SetParams(hci_adv_set_t handle,
                                                   brillo::ErrorPtr* error) {
  // Some chips can only support HCI_ADV_TYPE_ADV_IND.
  if (!libnewblue_->HciAdvSetSetAdvParams(
          handle, /* min_interval = */ 0x0040, /* max_interval = */ 0x0100,
          HCI_ADV_TYPE_ADV_IND, HCI_ADV_OWN_ADDR_TYPE_PUBLIC,
          /* address = */ nullptr,
          HCI_ADV_CHAN_MAP_USE_CHAN_37 | HCI_ADV_CHAN_MAP_USE_CHAN_38 |
              HCI_ADV_CHAN_MAP_USE_CHAN_39,
          HCI_ADV_FILTER_POL_SCAN_ALL_CONNECT_ALL,
          HCI_ADV_TX_PWR_LVL_DONT_CARE)) {
    brillo::Error::AddTo(error, FROM_HERE, brillo::errors::dbus::kDomain,
                         bluetooth_advertising_manager::kErrorFailed,
                         "Cannot set parameters");
    return false;
  }

  return true;
}

bool AdvertisingManagerInterfaceHandler::Enable(hci_adv_set_t handle,
                                                brillo::ErrorPtr* error) {
  if (!libnewblue_->HciAdvSetEnable(handle)) {
    brillo::Error::AddTo(error, FROM_HERE, brillo::errors::dbus::kDomain,
                         bluetooth_advertising_manager::kErrorFailed,
                         "Cannot enable advertisement");
    return false;
  }

  return true;
}

}  // namespace bluetooth