// Copyright 2019 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/gatt.h"
#include "bluetooth/newblued/util.h"

#include <string>
#include <utility>

namespace bluetooth {

namespace {

constexpr char kGattHumanInterfaceDeviceServiceUuid[] =
    "00001812-0000-1000-8000-00805f9b34fb";

// TODO(b:134425062): Implement profile manager so that the blacklist can be
// removed.
// Some GATT service should be kept only for newblued used due to security
// concern, and this works as a blacklist-filter.
bool IsHiddenGattService(const GattService& service) {
  std::string uuid = service.uuid().value().canonical_value();
  if (uuid.compare(kGattHumanInterfaceDeviceServiceUuid) == 0)
    return true;
  return false;
}

// Converts AttError to CattClientOperationError based on BlueZ.
GattClientOperationError ConvertToClientOperationError(AttError error) {
  switch (error) {
    case AttError::NONE:
      return GattClientOperationError::NONE;
    case AttError::READ_NOT_ALLOWED:
      return GattClientOperationError::READ_NOT_ALLOWED;
    case AttError::WRITE_NOT_ALLOWED:
      return GattClientOperationError::WRITE_NOT_ALLOWED;
    case AttError::INSUFF_AUTHN:
      return GattClientOperationError::INSUFF_AUTHN;
    case AttError::REQ_NOT_SUPPORTED:
      return GattClientOperationError::NOT_SUPPORTED;
    case AttError::INSUFF_AUTHZ:
      return GattClientOperationError::INSUFF_AUTHZ;
    case AttError::INVALID_OFFSET:
      return GattClientOperationError::INVALID_OFFSET;
    case AttError::INSUFF_ENCR_KEY_SIZE:
      return GattClientOperationError::INSUFF_ENCR_KEY_SIZE;
    case AttError::INVALID_ATTR_VALUE_LENGTH:
      return GattClientOperationError::INVALUD_ATTR_VALUE_LENGTH;
    case AttError::INSUFF_ENCR:
      return GattClientOperationError::INSUFF_ENC;
    default:  // This covers unknown AttError and the rest of AttError.
      return GattClientOperationError::OTHER;
  }
}

}  // namespace

Gatt::Gatt(Newblue* newblue, DeviceInterfaceHandler* device_interface_handler)
    : newblue_(newblue),
      device_interface_handler_(device_interface_handler),
      weak_ptr_factory_(this) {
  CHECK(newblue_);
  CHECK(device_interface_handler_);

  device_interface_handler_->AddDeviceObserver(this);
}

Gatt::~Gatt() {
  if (device_interface_handler_)
    device_interface_handler_->RemoveDeviceObserver(this);
}

void Gatt::AddGattObserver(GattObserver* observer) {
  CHECK(observer);
  observers_.AddObserver(observer);
}

void Gatt::RemoveGattObserver(GattObserver* observer) {
  CHECK(observer);
  observers_.RemoveObserver(observer);
}

UniqueId Gatt::ReadCharacteristicValue(
    const std::string& device_address,
    uint16_t service_handle,
    uint16_t char_handle,
    uint16_t offset,
    ReadCharacteristicValueCallback callback) {
  CHECK(!device_address.empty());
  CHECK(!callback.is_null());

  gatt_client_conn_t conn_id =
      device_interface_handler_->GetConnectionIdByAddress(device_address);
  if (conn_id == kInvalidGattConnectionId) {
    VLOG(1) << "Failed to read characteristic due to no connection with device "
            << device_address;
    return kInvalidUniqueId;
  }

  const auto characteristic =
      FindGattCharacteristic(device_address, service_handle, char_handle);
  if (characteristic == nullptr) {
    VLOG(1) << "Failed to locate characteristic with service handle "
            << service_handle << " characteristic handle " << char_handle
            << " for device " << device_address;
    return kInvalidUniqueId;
  }

  auto state = std::make_unique<ClientOperationState>(
      service_handle, char_handle, kInvalidGattAttributeHandle, offset);
  ClientOperation operation = {
      .operation_type = GattClientOperationType::READ_LONG_VALUE,
      .request_type = GattClientRequestType::READ_CHARACTERISTIC_VALUE,
      .conn_id = conn_id,
      .read_char_value_callback = std::move(callback)};
  auto transaction_id = GetNextId();
  transactions_.emplace(transaction_id, std::move(operation));

  uint16_t char_value_handle = characteristic->value_handle();
  auto status = newblue_->GattClientReadLongValue(
      conn_id, char_value_handle, GattClientOperationAuthentication::NONE,
      transaction_id,
      base::Bind(&Gatt::OnGattClientReadLongValue,
                 weak_ptr_factory_.GetWeakPtr(),
                 base::Passed(std::move(state))));
  if (status != GattClientOperationStatus::OK) {
    LOG(WARNING) << "Failed to read characteristic value with value handle "
                 << char_value_handle << " from device " << device_address
                 << " with conn ID " << conn_id << ", transaction "
                 << transaction_id;

    transactions_.erase(transaction_id);
    return kInvalidUniqueId;
  }

  VLOG(1) << "Read characteristic value with value handle " << char_value_handle
          << " from device " << device_address << " with conn ID " << conn_id;

  return transaction_id;
}

UniqueId Gatt::ReadDescriptorValue(const std::string& device_address,
                                   uint16_t service_handle,
                                   uint16_t char_handle,
                                   uint16_t desc_handle,
                                   uint16_t offset,
                                   ReadDescriptorValueCallback callback) {
  CHECK(!device_address.empty());
  CHECK(!callback.is_null());

  gatt_client_conn_t conn_id =
      device_interface_handler_->GetConnectionIdByAddress(device_address);
  if (conn_id == kInvalidGattConnectionId) {
    VLOG(1) << "Failed to read descriptor due to no connection with device "
            << device_address;
    return kInvalidUniqueId;
  }

  const auto descriptor = FindGattDescriptor(device_address, service_handle,
                                             char_handle, desc_handle);
  if (descriptor == nullptr) {
    VLOG(1) << "Failed to locate descriptor with service handle "
            << service_handle << " characteristic handle " << char_handle
            << " descriptor handle " << desc_handle << " for device "
            << device_address;
    return kInvalidUniqueId;
  }

  auto state = std::make_unique<ClientOperationState>(
      service_handle, char_handle, desc_handle, offset);
  ClientOperation operation = {
      .operation_type = GattClientOperationType::READ_LONG_VALUE,
      .request_type = GattClientRequestType::READ_DESCRIPTOR_VALUE,
      .conn_id = conn_id,
      .read_desc_value_callback = std::move(callback)};
  auto transaction_id = GetNextId();
  transactions_.emplace(transaction_id, std::move(operation));

  auto status = newblue_->GattClientReadLongValue(
      conn_id, desc_handle, GattClientOperationAuthentication::NONE,
      transaction_id,
      base::Bind(&Gatt::OnGattClientReadLongValue,
                 weak_ptr_factory_.GetWeakPtr(),
                 base::Passed(std::move(state))));
  if (status != GattClientOperationStatus::OK) {
    LOG(WARNING) << "Failed to read descriptor value with handle "
                 << desc_handle << " from device " << device_address
                 << " with conn ID " << conn_id << ", transaction "
                 << transaction_id;

    transactions_.erase(transaction_id);
    return kInvalidUniqueId;
  }

  VLOG(1) << "Read descriptor value with handle " << desc_handle
          << " from device " << device_address << " with conn ID " << conn_id;

  return transaction_id;
}

void Gatt::OnGattConnected(const std::string& device_address,
                           gatt_client_conn_t conn_id) {
  CHECK(!device_address.empty());

  auto services = remote_services_.find(device_address);
  if (services != remote_services_.end()) {
    LOG(WARNING) << "GATT cache for device " << device_address
                 << " was not cleared, clear it";
    remote_services_.erase(services);
  }

  // Start GATT browsing.
  UniqueId transaction_id = GetNextId();
  ClientOperation operation = {
      .operation_type = GattClientOperationType::SERVICES_ENUM,
      .request_type = GattClientRequestType::NONE,
      .conn_id = conn_id};
  transactions_.emplace(transaction_id, std::move(operation));

  GattClientOperationStatus status = newblue_->GattClientEnumServices(
      conn_id, true, transaction_id,
      base::Bind(&Gatt::OnGattClientEnumServices,
                 weak_ptr_factory_.GetWeakPtr()));
  if (status != GattClientOperationStatus::OK) {
    LOG(ERROR) << "Failed to browse GATT for device " << device_address
               << " with conn ID " << conn_id;
    transactions_.erase(transaction_id);
  }

  VLOG(1) << "Start GATT browsing for device " << device_address
          << ", transaction " << transaction_id;
}

void Gatt::OnGattDisconnected(const std::string& device_address,
                              gatt_client_conn_t conn_id,
                              bool is_disconnected_by_newblue) {
  CHECK(!device_address.empty());

  // TODO(b:137581907): Investigate if the removal of transaction can rely on
  // the callbacks of GATT operations.
  for (std::map<UniqueId, ClientOperation>::iterator transaction =
           transactions_.begin();
       transaction != transactions_.end();) {
    if (transaction->second.conn_id == conn_id) {
      VLOG(2) << "Clear ongoing GATT client transaction " << transaction->first
              << " with device " << device_address;
      transactions_.erase(transaction++);
    } else {
      ++transaction;
    }
  }

  device_interface_handler_->SetGattServicesResolved(device_address,
                                                     false /* resolved */);

  const auto services = remote_services_.find(device_address);
  if (services != remote_services_.end()) {
    VLOG(1) << "Clear the cached GATT services of device " << device_address;
    for (auto& observer : observers_) {
      for (const auto& service : services->second) {
        if (IsHiddenGattService(*service.second))
          continue;

        for (const auto& characteristic : service.second->characteristics()) {
          for (const auto& descriptor : characteristic.second->descriptors())
            observer.OnGattDescriptorRemoved(*descriptor.second);

          observer.OnGattCharacteristicRemoved(*characteristic.second);
        }
        observer.OnGattServiceRemoved(*service.second);
      }
    }
    remote_services_.erase(device_address);
  }
}

void Gatt::TravPrimaryServices(const std::string& device_address,
                               gatt_client_conn_t conn_id) {
  auto services = remote_services_.find(device_address);

  if (services == remote_services_.end()) {
    LOG(WARNING) << "Failed to find remote services associated with device "
                 << device_address;
    return;
  }

  for (const auto& service_entry : services->second) {
    GattService* service = service_entry.second.get();

    if (!service->primary().value())
      continue;

    UniqueId transaction_id = GetNextId();
    ClientOperation operation = {
        .operation_type = GattClientOperationType::PRIMARY_SERVICE_TRAV,
        .request_type = GattClientRequestType::NONE,
        .conn_id = conn_id};
    transactions_.emplace(transaction_id, std::move(operation));

    GattClientOperationStatus status = newblue_->GattClientTravPrimaryService(
        conn_id, service->uuid().value(), transaction_id,
        base::Bind(&Gatt::OnGattClientTravPrimaryService,
                   weak_ptr_factory_.GetWeakPtr()));
    if (status != GattClientOperationStatus::OK) {
      LOG(ERROR) << "Failed to traverse GATT primary service "
                 << service->uuid().value().canonical_value() << " for device "
                 << device_address << " with conn ID " << conn_id;
      transactions_.erase(transaction_id);
    } else {
      VLOG(1) << "Start traversing GATT primary service "
              << service->uuid().value().canonical_value() << " for device "
              << device_address << ", transaction " << transaction_id;
    }
  }
}

void Gatt::OnGattClientEnumServices(bool finished,
                                    gatt_client_conn_t conn_id,
                                    UniqueId transaction_id,
                                    Uuid uuid,
                                    bool primary,
                                    uint16_t first_handle,
                                    uint16_t num_handles,
                                    GattClientOperationStatus status) {
  auto transaction = transactions_.find(transaction_id);
  CHECK(transaction != transactions_.end());
  CHECK(transaction->second.operation_type ==
        GattClientOperationType::SERVICES_ENUM);

  if (status != GattClientOperationStatus::OK) {
    LOG(ERROR) << "Error GATT client operation, dropping it";
    return;
  }

  // This may be invoked after device is removed, so we check whether the device
  // is still valid.
  std::string device_address =
      device_interface_handler_->GetAddressByConnectionId(conn_id);
  if (device_address.empty()) {
    LOG(WARNING) << "Unknown GATT connection " << conn_id
                 << " for service enumeration result";
    return;
  }

  // Close the transaction when the service enumeration finished.
  if (finished) {
    VLOG(1) << "GATT browsing finished for device " << device_address
            << ", transaction " << transaction_id;
    transactions_.erase(transaction_id);

    // Start primary services traversal.
    TravPrimaryServices(device_address, conn_id);
    return;
  }

  VLOG(2) << "GATT Browsing continues on device " << device_address
          << ", transaction " << transaction_id << ", found "
          << uuid.canonical_value();

  if (!base::Contains(remote_services_, device_address)) {
    std::map<uint16_t, std::unique_ptr<GattService>> services;
    remote_services_.emplace(device_address, std::move(services));
  }

  auto services = remote_services_.find(device_address);
  services->second.emplace(first_handle,
                           std::make_unique<GattService>(
                               device_address, first_handle,
                               first_handle + num_handles - 1, primary, uuid));
  for (auto& observer : observers_) {
    if (IsHiddenGattService(*services->second.at(first_handle)))
      continue;

    observer.OnGattServiceAdded(
        *remote_services_.at(device_address).at(first_handle));
  }
}

void Gatt::OnGattClientTravPrimaryService(
    gatt_client_conn_t conn_id,
    UniqueId transaction_id,
    std::unique_ptr<GattService> service) {
  auto transaction = transactions_.find(transaction_id);
  CHECK(transaction != transactions_.end());
  CHECK(transaction->second.operation_type ==
        GattClientOperationType::PRIMARY_SERVICE_TRAV);

  // This may be invoked after device is removed, so we check whether the device
  // is still valid.
  std::string device_address =
      device_interface_handler_->GetAddressByConnectionId(conn_id);
  if (device_address.empty()) {
    LOG(WARNING) << "Unknown GATT connection " << conn_id
                 << " for primary service traversal result";
    transactions_.erase(transaction_id);
    return;
  }

  if (service == nullptr) {
    LOG(ERROR) << "Primary service traversal failed with device "
               << device_address;
    transactions_.erase(transaction_id);
    return;
  }

  auto services = remote_services_.find(device_address);
  if (services == remote_services_.end()) {
    LOG(WARNING) << "No remote services associated with device "
                 << device_address << ", dropping it";
    transactions_.erase(transaction_id);
    return;
  }

  // If there is service change before the traversal finished where the service
  // is no longer there, we drop the result.
  auto srv = services->second.find(service->first_handle());
  if (srv == services->second.end()) {
    LOG(WARNING) << "Unknown primary service "
                 << service->uuid().value().canonical_value()
                 << ", dropping it";
    transactions_.erase(transaction_id);
    return;
  }

  CHECK(srv->second->device_address().value() == device_address);

  VLOG(2) << "Replacing service " << service->uuid().value().canonical_value()
          << " of device " << device_address
          << " with the traversed one, transaction id " << transaction_id;

  service->SetDeviceAddress(device_address);
  srv->second = std::move(service);
  transactions_.erase(transaction_id);

  // Notify observers on service-changed, characteristic-added and
  // descriptor-added events.
  for (auto& observer : observers_) {
    if (IsHiddenGattService(*srv->second))
      continue;

    observer.OnGattServiceChanged(*srv->second);
    for (const auto& characteristic : srv->second->characteristics()) {
      observer.OnGattCharacteristicAdded(*characteristic.second);

      for (const auto& descriptor : characteristic.second->descriptors())
        observer.OnGattDescriptorAdded(*descriptor.second);
    }
  }

  // Notify device interface handler about the completion of traversal.
  if (IsTravPrimaryServicesCompleted(conn_id)) {
    VLOG(1) << "GATT primary services traversal finished for device "
            << device_address;
    device_interface_handler_->SetGattServicesResolved(device_address,
                                                       true /* resolved */);
  }
}

bool Gatt::IsTravPrimaryServicesCompleted(gatt_client_conn_t conn_id) {
  for (const auto& transaction : transactions_) {
    if (transaction.second.conn_id == conn_id &&
        transaction.second.operation_type ==
            GattClientOperationType::PRIMARY_SERVICE_TRAV) {
      return false;
    }
  }
  return true;
}

GattCharacteristic* Gatt::FindGattCharacteristic(
    const std::string& device_address,
    uint16_t service_handle,
    uint16_t char_handle) const {
  if (device_address.empty() || service_handle == kInvalidGattAttributeHandle ||
      char_handle == kInvalidGattAttributeHandle) {
    return nullptr;
  }

  auto services = remote_services_.find(device_address);
  if (services == remote_services_.end())
    return nullptr;

  auto service = services->second.find(service_handle);
  if (service == services->second.end())
    return nullptr;

  auto characteristic = service->second->characteristics().find(char_handle);
  if (characteristic == service->second->characteristics().end())
    return nullptr;

  return characteristic->second.get();
}

GattDescriptor* Gatt::FindGattDescriptor(const std::string& device_address,
                                         uint16_t service_handle,
                                         uint16_t char_handle,
                                         uint16_t desc_handle) const {
  auto characteristic =
      FindGattCharacteristic(device_address, service_handle, char_handle);
  if (characteristic == nullptr)
    return nullptr;

  auto descriptor = characteristic->descriptors().find(desc_handle);
  if (descriptor == characteristic->descriptors().end())
    return nullptr;

  return descriptor->second.get();
}

void Gatt::OnGattClientReadLongValue(
    std::unique_ptr<ClientOperationState> state,
    gatt_client_conn_t conn_id,
    UniqueId transaction_id,
    uint16_t value_handle,
    AttError error,
    const std::vector<uint8_t>& value) {
  auto transaction = transactions_.find(transaction_id);
  CHECK(transaction != transactions_.end());
  CHECK(transaction->second.operation_type ==
        GattClientOperationType::READ_LONG_VALUE);

  std::string device_address =
      device_interface_handler_->GetAddressByConnectionId(conn_id);
  if (device_address.empty()) {
    LOG(WARNING) << "Unknown GATT conn ID " << conn_id
                 << " for read value result, dropping transaction "
                 << transaction_id;
    transactions_.erase(transaction_id);
    return;
  }

  switch (transaction->second.request_type) {
    case GattClientRequestType::READ_CHARACTERISTIC_VALUE:
      OnGattClientReadLongCharacteristicValue(std::move(state), device_address,
                                              transaction_id, value_handle,
                                              error, value);
      return;
    case GattClientRequestType::READ_DESCRIPTOR_VALUE:
      OnGattClientReadLongDescriptorValue(std::move(state), device_address,
                                          transaction_id, value_handle, error,
                                          value);
      return;
    default:
      LOG(WARNING) << "Unexpected GATT client request "
                   << static_cast<uint8_t>(transaction->second.request_type)
                   << ", transaction" << transaction_id;
      transactions_.erase(transaction_id);
      return;
  }
}

void Gatt::OnGattClientReadLongCharacteristicValue(
    std::unique_ptr<ClientOperationState> state,
    const std::string& device_address,
    UniqueId transaction_id,
    uint16_t value_handle,
    AttError error,
    const std::vector<uint8_t>& value) {
  CHECK(state != nullptr);

  auto characteristic = FindGattCharacteristic(
      device_address, state->service_handle, state->char_handle);
  if (characteristic == nullptr) {
    LOG(WARNING) << "Failed to locate characteristic with service handle "
                 << state->service_handle << " characteristic handle "
                 << state->char_handle << " for device " << device_address
                 << ", dropping it";
    transactions_.erase(transaction_id);
    return;
  }

  CHECK(characteristic->value_handle() == value_handle);

  if (value.empty()) {
    LOG(WARNING) << "Error GATT client read characteristic value with handle "
                 << value_handle << " from given device " << device_address
                 << ", error code " << static_cast<uint8_t>(error);
  } else {
    // Concatenate the latest value fragment to the tail.
    state->value.insert(state->value.end(), value.begin(), value.end());

    if (state->offset >= state->value.size()) {
      error = AttError::INVALID_OFFSET;
      LOG(WARNING) << "Error GATT client read characteristic value with handle "
                   << value_handle << " from given device " << device_address
                   << ", error code " << static_cast<uint8_t>(error);

      state->value.clear();
    } else {
      VLOG(1) << "GATT client read characteristic value with handle "
              << value_handle << " finished for device " << device_address
              << ", transaction " << transaction_id;

      state->value.erase(state->value.begin(),
                         state->value.begin() + state->offset);
    }
  }

  // Notify observers on both successful and failed read of characteristic.
  characteristic->SetValue(state->value);
  for (auto& observer : observers_)
    observer.OnGattCharacteristicChanged(*characteristic);
  characteristic->ResetPropertiesUpdated();

  // In the error cases, we still report the values that we read so far.
  auto callback =
      std::move(transactions_.at(transaction_id).read_char_value_callback);
  transactions_.erase(transaction_id);
  callback.Run(transaction_id, device_address, state->service_handle,
               state->char_handle, ConvertToClientOperationError(error),
               state->value);
}

void Gatt::OnGattClientReadLongDescriptorValue(
    std::unique_ptr<ClientOperationState> state,
    const std::string& device_address,
    UniqueId transaction_id,
    uint16_t value_handle,
    AttError error,
    const std::vector<uint8_t>& value) {
  CHECK(state != nullptr);

  auto descriptor = FindGattDescriptor(device_address, state->service_handle,
                                       state->char_handle, state->desc_handle);
  if (descriptor == nullptr) {
    LOG(WARNING) << "Failed to locate descriptor with service handle "
                 << state->service_handle << " characteristic handle "
                 << state->char_handle << " descriptor handle "
                 << state->desc_handle << " for device " << device_address
                 << ", dropping it";
    transactions_.erase(transaction_id);
    return;
  }

  CHECK(state->desc_handle == value_handle);

  if (value.empty()) {
    LOG(WARNING) << "Error GATT client read descriptor value with handle "
                 << value_handle << " from given device " << device_address
                 << ", error code " << static_cast<uint8_t>(error);
  } else {
    // Concatenate the latest value fragment to the tail.
    state->value.insert(state->value.end(), value.begin(), value.end());

    if (state->offset >= state->value.size()) {
      error = AttError::INVALID_OFFSET;
      LOG(WARNING) << "Error GATT client read descriptor value with handle "
                   << value_handle << " from given device " << device_address
                   << ", error code " << static_cast<uint8_t>(error);

      state->value.clear();
    } else {
      VLOG(1) << "GATT client read descriptor value with handle "
              << value_handle << " finished for device " << device_address
              << ", transaction " << transaction_id;

      state->value.erase(state->value.begin(),
                         state->value.begin() + state->offset);
    }
  }

  // Notify observers on both successful and failed read of descriptor.
  descriptor->SetValue(state->value);
  for (auto& observer : observers_)
    observer.OnGattDescriptorChanged(*descriptor);
  descriptor->ResetPropertiesUpdated();

  // In the error cases, we still report the values that we read so far.
  auto callback =
      std::move(transactions_.at(transaction_id).read_desc_value_callback);
  transactions_.erase(transaction_id);
  callback.Run(transaction_id, device_address, state->service_handle,
               state->char_handle, state->desc_handle,
               ConvertToClientOperationError(error), state->value);
}

}  // namespace bluetooth