/*
 * Copyright 2022 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 "remote_name_request.h"

#include <bluetooth/log.h>
#include <com_android_bluetooth_flags.h>

#include "hci/acl_manager/acl_scheduler.h"
#include "hci/hci_layer.h"
#include "hci/hci_packets.h"

namespace bluetooth {
namespace hci {

struct RemoteNameRequestModule::impl {
public:
  impl(const RemoteNameRequestModule& module) : module_(module) {}

  void Start() {
    log::info("Starting RemoteNameRequestModule");
    hci_layer_ = module_.GetDependency<HciLayer>();
    acl_scheduler_ = module_.GetDependency<acl_manager::AclScheduler>();
    handler_ = module_.GetHandler();

    hci_layer_->RegisterEventHandler(
            EventCode::REMOTE_HOST_SUPPORTED_FEATURES_NOTIFICATION,
            handler_->BindOn(this, &RemoteNameRequestModule::impl::
                                           on_remote_host_supported_features_notification));
    hci_layer_->RegisterEventHandler(
            EventCode::REMOTE_NAME_REQUEST_COMPLETE,
            handler_->BindOn(this,
                             &RemoteNameRequestModule::impl::on_remote_name_request_complete));
  }

  void Stop() {
    log::info("Stopping RemoteNameRequestModule");
    hci_layer_->UnregisterEventHandler(EventCode::REMOTE_HOST_SUPPORTED_FEATURES_NOTIFICATION);
    hci_layer_->UnregisterEventHandler(EventCode::REMOTE_NAME_REQUEST_COMPLETE);
  }

  void StartRemoteNameRequest(
          Address address, std::unique_ptr<RemoteNameRequestBuilder> request,
          CompletionCallback on_completion,
          RemoteHostSupportedFeaturesCallback on_remote_host_supported_features_notification,
          RemoteNameCallback on_remote_name_complete) {
    log::info("Enqueuing remote name request to {}", address.ToRedactedStringForLogging());

    // This callback needs to be shared between the *start* callback and the *cancel_completed*
    // callback, so we refcount it for safety. But since the scheduler guarantees that exactly one
    // of these callbacks will be invokes, this is safe.
    auto on_remote_name_complete_ptr =
            std::make_shared<RemoteNameCallback>(std::move(on_remote_name_complete));

    acl_scheduler_->EnqueueRemoteNameRequest(
            address,
            handler_->BindOnceOn(this, &impl::actually_start_remote_name_request, address,
                                 std::move(request), std::move(on_completion),
                                 std::move(on_remote_host_supported_features_notification),
                                 on_remote_name_complete_ptr),
            handler_->BindOnce(
                    [&](Address address,
                        std::shared_ptr<RemoteNameCallback> on_remote_name_complete_ptr) {
                      log::info("Dequeued remote name request to {} since it was cancelled",
                                address.ToRedactedStringForLogging());
                      (*on_remote_name_complete_ptr)(ErrorCode::PAGE_TIMEOUT, {});
                    },
                    address, on_remote_name_complete_ptr));
  }

  void CancelRemoteNameRequest(Address address) {
    log::info("Enqueuing cancel of remote name request to {}",
              address.ToRedactedStringForLogging());
    acl_scheduler_->CancelRemoteNameRequest(
            address,
            handler_->BindOnceOn(this, &impl::actually_cancel_remote_name_request, address));
  }

  void ReportRemoteNameRequestCancellation(Address address) {
    if (pending_) {
      log::info(
              "Received CONNECTION_COMPLETE (corresponding INCORRECTLY to an RNR cancellation) "
              "from {}",
              address.ToRedactedStringForLogging());
      pending_ = false;
      on_remote_name_complete_(ErrorCode::UNKNOWN_CONNECTION, {});
      acl_scheduler_->ReportRemoteNameRequestCompletion(address);
    } else {
      log::error(
              "Received unexpected CONNECTION_COMPLETE when no Remote Name Request OR ACL "
              "connection is outstanding");
    }
  }

private:
  void actually_start_remote_name_request(
          Address address, std::unique_ptr<RemoteNameRequestBuilder> request,
          CompletionCallback on_completion,
          RemoteHostSupportedFeaturesCallback on_remote_host_supported_features_notification,
          std::shared_ptr<RemoteNameCallback> on_remote_name_complete_ptr) {
    log::info("Starting remote name request to {}", address.ToRedactedStringForLogging());
    log::assert_that(pending_ == false, "assert failed: pending_ == false");
    pending_ = true;
    on_remote_host_supported_features_notification_ =
            std::move(on_remote_host_supported_features_notification);
    on_remote_name_complete_ = std::move(*on_remote_name_complete_ptr.get());
    hci_layer_->EnqueueCommand(
            std::move(request),
            handler_->BindOnceOn(this, &impl::on_start_remote_name_request_status, address,
                                 std::move(on_completion)));
  }

  void on_start_remote_name_request_status(Address address, CompletionCallback on_completion,
                                           CommandStatusView status) {
    // TODO(b/294961421): Remove the ifdef when firmware fix in place. Realtek controllers
    // unexpectedly sent a Remote Name Req Complete HCI event without the corresponding HCI command.
#ifndef TARGET_FLOSS
    log::assert_that(pending_ == true, "assert failed: pending_ == true");
#else
    if (pending_ != true) {
      log::warn("Unexpected remote name response with no request pending");
      return;
    }
#endif
    log::assert_that(status.GetCommandOpCode() == OpCode::REMOTE_NAME_REQUEST,
                     "assert failed: status.GetCommandOpCode() == OpCode::REMOTE_NAME_REQUEST");
    log::info("Started remote name request peer:{} status:{}", address.ToRedactedStringForLogging(),
              ErrorCodeText(status.GetStatus()));
    on_completion(status.GetStatus());
    if (status.GetStatus() != ErrorCode::SUCCESS /* pending */) {
      pending_ = false;
      acl_scheduler_->ReportRemoteNameRequestCompletion(address);
    }
  }

  void actually_cancel_remote_name_request(Address address) {
    if (pending_) {
      log::info("Cancelling remote name request to {}", address.ToRedactedStringForLogging());
      hci_layer_->EnqueueCommand(RemoteNameRequestCancelBuilder::Create(address),
                                 handler_->BindOnceOn(this, &impl::check_cancel_status, address));
    } else {
      log::info("Ignoring cancel RNR as RNR event already received to {}",
                address.ToRedactedStringForLogging());
    }
  }

  void on_remote_host_supported_features_notification(EventView view) {
    auto packet = RemoteHostSupportedFeaturesNotificationView::Create(view);
    log::assert_that(packet.IsValid(), "assert failed: packet.IsValid()");
    if (pending_ && on_remote_host_supported_features_notification_) {
      log::info("Received REMOTE_HOST_SUPPORTED_FEATURES_NOTIFICATION from {}",
                packet.GetBdAddr().ToRedactedStringForLogging());
      on_remote_host_supported_features_notification_(packet.GetHostSupportedFeatures());
      // Remove the callback so that we won't call it again.
      on_remote_host_supported_features_notification_ = RemoteHostSupportedFeaturesCallback();
    } else if (!pending_) {
      log::error(
              "Received unexpected REMOTE_HOST_SUPPORTED_FEATURES_NOTIFICATION when no Remote Name "
              "Request is outstanding");
    } else {  // callback is not set, which indicates we have processed the feature notification.
      log::error(
              "Received more than one REMOTE_HOST_SUPPORTED_FEATURES_NOTIFICATION during Remote "
              "Name Request");
    }
  }

  void completed(ErrorCode status, std::array<uint8_t, 248> name, Address address) {
    if (pending_) {
      log::info("Received REMOTE_NAME_REQUEST_COMPLETE from {} with status {}",
                address.ToRedactedStringForLogging(), ErrorCodeText(status));
      pending_ = false;
      on_remote_name_complete_(status, name);
      acl_scheduler_->ReportRemoteNameRequestCompletion(address);
    } else {
      log::error("Received unexpected REMOTE_NAME_REQUEST_COMPLETE from {} with status {}",
                 address.ToRedactedStringForLogging(), ErrorCodeText(status));
    }
  }

  void on_remote_name_request_complete(EventView view) {
    auto packet = RemoteNameRequestCompleteView::Create(view);
    log::assert_that(packet.IsValid(), "Invalid packet");
    completed(packet.GetStatus(), packet.GetRemoteName(), packet.GetBdAddr());
  }

  void check_cancel_status(Address remote, CommandCompleteView complete) {
    auto packet = RemoteNameRequestCancelCompleteView::Create(complete);
    if (!packet.IsValid()) {
      completed(ErrorCode::UNSPECIFIED_ERROR, std::array<uint8_t, 248>{}, remote);
      return;
    }
    auto status = packet.GetStatus();
    if (status != ErrorCode::SUCCESS) {
      completed(status, std::array<uint8_t, 248>{}, packet.GetBdAddr());
    }
  }

  const RemoteNameRequestModule& module_;
  HciLayer* hci_layer_;
  acl_manager::AclScheduler* acl_scheduler_;
  os::Handler* handler_;

  bool pending_ = false;
  RemoteHostSupportedFeaturesCallback on_remote_host_supported_features_notification_;
  RemoteNameCallback on_remote_name_complete_;
};

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

RemoteNameRequestModule::RemoteNameRequestModule() : pimpl_(std::make_unique<impl>(*this)) {}
RemoteNameRequestModule::~RemoteNameRequestModule() = default;

void RemoteNameRequestModule::StartRemoteNameRequest(
        Address address, std::unique_ptr<RemoteNameRequestBuilder> request,
        CompletionCallback on_completion,
        RemoteHostSupportedFeaturesCallback on_remote_host_supported_features_notification,
        RemoteNameCallback on_remote_name_complete) {
  CallOn(pimpl_.get(), &impl::StartRemoteNameRequest, address, std::move(request),
         std::move(on_completion), std::move(on_remote_host_supported_features_notification),
         std::move(on_remote_name_complete));
}

void RemoteNameRequestModule::CancelRemoteNameRequest(Address address) {
  CallOn(pimpl_.get(), &impl::CancelRemoteNameRequest, address);
}

void RemoteNameRequestModule::ReportRemoteNameRequestCancellation(Address address) {
  CallOn(pimpl_.get(), &impl::ReportRemoteNameRequestCancellation, address);
}

void RemoteNameRequestModule::ListDependencies(ModuleList* list) const {
  list->add<HciLayer>();
  list->add<acl_manager::AclScheduler>();
}

void RemoteNameRequestModule::Start() { pimpl_->Start(); }

void RemoteNameRequestModule::Stop() { pimpl_->Stop(); }

}  // namespace hci
}  // namespace bluetooth