// Copyright 2024 The Pigweed Authors
//
// 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
//
//     https://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 "pw_bluetooth_proxy/proxy_host.h"

#include <mutex>

#include "pw_bluetooth/emboss_util.h"
#include "pw_bluetooth/hci_commands.emb.h"
#include "pw_bluetooth/hci_common.emb.h"
#include "pw_bluetooth/hci_h4.emb.h"
#include "pw_bluetooth_proxy/h4_packet.h"
#include "pw_bluetooth_proxy/internal/logical_transport.h"
#include "pw_bluetooth_proxy/l2cap_channel_common.h"
#include "pw_log/log.h"

namespace pw::bluetooth::proxy {

ProxyHost::ProxyHost(
    pw::Function<void(H4PacketWithHci&& packet)>&& send_to_host_fn,
    pw::Function<void(H4PacketWithH4&& packet)>&& send_to_controller_fn,
    uint16_t le_acl_credits_to_reserve,
    uint16_t br_edr_acl_credits_to_reserve,
    pw::Allocator* allocator)
    : impl_(*this),
      hci_transport_(std::move(send_to_host_fn),
                     std::move(send_to_controller_fn)),
      acl_data_channel_(hci_transport_,
                        le_acl_credits_to_reserve,
                        br_edr_acl_credits_to_reserve,
                        *allocator,
                        /*on_tx_credits_fn=*/[this]() { OnAclTxCredits(); }),
      l2cap_channel_manager_(acl_data_channel_, *allocator) {
  PW_LOG_INFO(
      "btproxy: ProxyHost ctor - le_acl_credits_to_reserve: %u, "
      "br_edr_acl_credits_to_reserve: %u",
      le_acl_credits_to_reserve,
      br_edr_acl_credits_to_reserve);
}

ProxyHost::ProxyHost(
    pw::Function<void(H4PacketWithHci&& packet)>&& send_to_host_fn,
    pw::Function<void(H4PacketWithH4&& packet)>&& send_to_controller_fn,
    pw::Allocator& allocator)
    : impl_(*this),
      hci_transport_(std::move(send_to_host_fn),
                     std::move(send_to_controller_fn)),
      acl_data_channel_(hci_transport_,
                        allocator,
                        /*on_tx_credits_fn=*/[this]() { OnAclTxCredits(); }),
      l2cap_channel_manager_(acl_data_channel_, allocator) {
  PW_LOG_INFO("btproxy: ProxyHost ctor - Dynamic Credit Sharing");
}

ProxyHost::~ProxyHost() {
  PW_LOG_INFO("btproxy: ProxyHost dtor");
  acl_data_channel_.Reset();
  l2cap_channel_manager_.DeregisterAndCloseChannels(
      L2capChannelEvent::kChannelClosedByOther);
}

void ProxyHost::SetEventBlocked(emboss::EventCode event_code, bool blocked) {
  std::lock_guard lock(filter_mutex_);
  blocked_events_.set(static_cast<uint8_t>(event_code), blocked);
}

void ProxyHost::SetLeSubeventBlocked(emboss::LeSubEventCode subevent_code,
                                     bool blocked) {
  std::lock_guard lock(filter_mutex_);
  blocked_le_subevents_.set(static_cast<uint8_t>(subevent_code), blocked);
}

void ProxyHost::ResetFilters() {
  std::lock_guard lock(filter_mutex_);
  blocked_events_.reset();
  blocked_le_subevents_.reset();
}

bool ProxyHost::IsEventBlocked(emboss::EventCode event_code) const {
  std::lock_guard lock(filter_mutex_);
  return blocked_events_.test(static_cast<uint8_t>(event_code));
}

bool ProxyHost::IsLeSubeventBlocked(
    emboss::LeSubEventCode subevent_code) const {
  std::lock_guard lock(filter_mutex_);
  return blocked_le_subevents_.test(static_cast<uint8_t>(subevent_code));
}

void ProxyHost::DoReset() {
  // Reset AclDataChannel first, so that send credits are reset to 0 until
  // reinitialized by controller event. This way, new channels can still be
  // registered, but they cannot erroneously use invalidated send credits.
  acl_data_channel_.Reset();
  l2cap_channel_manager_.DeregisterAndCloseChannels(L2capChannelEvent::kReset);
}

void ProxyHost::DoHandleH4HciFromHost(H4PacketWithH4&& h4_packet) {
  switch (h4_packet.GetH4Type()) {
    case emboss::H4PacketType::COMMAND:
      HandleCommandFromHost(std::move(h4_packet));
      return;
    case emboss::H4PacketType::ACL_DATA:
      HandleAclFromHost(std::move(h4_packet));
      return;
    case emboss::H4PacketType::EVENT:
    case emboss::H4PacketType::UNKNOWN:
    case emboss::H4PacketType::SYNC_DATA:
    case emboss::H4PacketType::ISO_DATA:
    default:
      hci_transport_.SendToController(std::move(h4_packet));
      return;
  }
}

void ProxyHost::DoHandleH4HciFromController(H4PacketWithHci&& h4_packet) {
  switch (h4_packet.GetH4Type()) {
    case emboss::H4PacketType::EVENT:
      HandleEventFromController(std::move(h4_packet));
      return;
    case emboss::H4PacketType::ACL_DATA:
      HandleAclFromController(std::move(h4_packet));
      return;
    case emboss::H4PacketType::UNKNOWN:
    case emboss::H4PacketType::COMMAND:
    case emboss::H4PacketType::SYNC_DATA:
    case emboss::H4PacketType::ISO_DATA:
    default:
      hci_transport_.SendToHost(std::move(h4_packet));
      return;
  }
}

void ProxyHost::HandleEventFromController(H4PacketWithHci&& h4_packet) {
  pw::span<uint8_t> hci_buffer = h4_packet.GetHciSpan();
  Result<emboss::EventHeaderView> event =
      MakeEmbossView<emboss::EventHeaderView>(hci_buffer);
  if (!event.ok()) {
    PW_LOG_ERROR(
        "Buffer is too small for EventHeader. So will pass on to host without "
        "processing.");
    hci_transport_.SendToHost(std::move(h4_packet));
    return;
  }

  bool should_send_to_host = true;
  bool should_deliver_pending_events = true;
  emboss::EventCode event_code = event->event_code().Read();

  PW_MODIFY_DIAGNOSTICS_PUSH();
  PW_MODIFY_DIAGNOSTIC(ignored, "-Wswitch-enum");
  switch (event_code) {
    case emboss::EventCode::NUMBER_OF_COMPLETED_PACKETS: {
      should_send_to_host =
          acl_data_channel_.HandleNumberOfCompletedPacketsEvent(h4_packet);
      break;
    }
    case emboss::EventCode::DISCONNECTION_COMPLETE: {
      Result<emboss::DisconnectionCompleteEventView> dc_event =
          MakeEmbossView<emboss::DisconnectionCompleteEventView>(
              h4_packet.GetHciSpan());
      if (dc_event.ok() &&
          dc_event->status().Read() == emboss::StatusCode::SUCCESS) {
        uint16_t conn_handle = dc_event->connection_handle().Read();
        l2cap_channel_manager_.HandleAclDisconnectionComplete(conn_handle);
        acl_data_channel_.ProcessDisconnectionCompleteEvent(
            conn_handle, dc_event->reason().Read());
      }
      break;
    }
    case emboss::EventCode::COMMAND_COMPLETE: {
      should_send_to_host = HandleCommandCompleteEvent(h4_packet);
      break;
    }
    case emboss::EventCode::CONNECTION_COMPLETE: {
      pw::span<uint8_t> hci_span = h4_packet.GetHciSpan();
      Result<emboss::ConnectionCompleteEventView> connection_complete_event =
          MakeEmbossView<emboss::ConnectionCompleteEventView>(hci_span);
      if (connection_complete_event.ok() &&
          connection_complete_event->status().Read() ==
              emboss::StatusCode::SUCCESS) {
        OnConnectionCompleteSuccess(
            connection_complete_event->connection_handle().Read(),
            AclTransportType::kBrEdr);
      }
      break;
    }
    case emboss::EventCode::LE_META_EVENT: {
      should_send_to_host = HandleLeMetaEvent(h4_packet);
      break;
    }
    default: {
      should_deliver_pending_events = false;
      break;
    }
  }
  PW_MODIFY_DIAGNOSTICS_POP();

  if (should_send_to_host && !IsEventBlocked(event_code)) {
    hci_transport_.SendToHost(std::move(h4_packet));
  }

  if (should_deliver_pending_events) {
    l2cap_channel_manager_.DeliverPendingEvents();
  }
}

void ProxyHost::HandleAclFromController(H4PacketWithHci&& h4_packet) {
  acl_data_channel_.HandleAclFromController(std::move(h4_packet));
  //  It's possible for a channel handling rx traffic to have queued tx traffic
  //  or events.
  l2cap_channel_manager_.DrainChannelQueuesIfNewTx();
  l2cap_channel_manager_.DeliverPendingEvents();
}

bool ProxyHost::HandleLeMetaEvent(H4PacketWithHci& h4_packet) {
  pw::span<uint8_t> hci_buffer = h4_packet.GetHciSpan();
  Result<emboss::LEMetaEventView> le_meta_event_view =
      MakeEmbossView<emboss::LEMetaEventView>(hci_buffer);
  if (!le_meta_event_view.ok()) {
    PW_LOG_ERROR(
        "Buffer is too small for LE_META_EVENT event. So will not process.");
    return true;
  }

  PW_MODIFY_DIAGNOSTICS_PUSH();
  PW_MODIFY_DIAGNOSTIC(ignored, "-Wswitch-enum");
  switch (le_meta_event_view->subevent_code_enum().Read()) {
    case emboss::LeSubEventCode::CONNECTION_COMPLETE: {
      Result<emboss::LEConnectionCompleteSubeventView> event =
          MakeEmbossView<emboss::LEConnectionCompleteSubeventView>(hci_buffer);
      if (event.ok() && event->status().Read() == emboss::StatusCode::SUCCESS) {
        OnConnectionCompleteSuccess(event->connection_handle().Read(),
                                    AclTransportType::kLe);
      }
      break;
    }
    case emboss::LeSubEventCode::ENHANCED_CONNECTION_COMPLETE_V1: {
      Result<emboss::LEEnhancedConnectionCompleteSubeventV1View> event =
          MakeEmbossView<emboss::LEEnhancedConnectionCompleteSubeventV1View>(
              hci_buffer);
      if (event.ok() && event->status().Read() == emboss::StatusCode::SUCCESS) {
        OnConnectionCompleteSuccess(event->connection_handle().Read(),
                                    AclTransportType::kLe);
      }
      break;
    }
    case emboss::LeSubEventCode::ENHANCED_CONNECTION_COMPLETE_V2: {
      Result<emboss::LEEnhancedConnectionCompleteSubeventV2View> event =
          MakeEmbossView<emboss::LEEnhancedConnectionCompleteSubeventV2View>(
              hci_buffer);
      if (event.ok() && event->status().Read() == emboss::StatusCode::SUCCESS) {
        OnConnectionCompleteSuccess(event->connection_handle().Read(),
                                    AclTransportType::kLe);
      }
      break;
    }
    default:
      break;
  }
  PW_MODIFY_DIAGNOSTICS_POP();

  return !IsLeSubeventBlocked(le_meta_event_view->subevent_code_enum().Read());
}

bool ProxyHost::HandleCommandCompleteEvent(H4PacketWithHci& h4_packet) {
  pw::span<uint8_t> hci_buffer = h4_packet.GetHciSpan();
  Result<emboss::CommandCompleteEventView> command_complete_event =
      MakeEmbossView<emboss::CommandCompleteEventView>(hci_buffer);
  if (!command_complete_event.ok()) {
    PW_LOG_ERROR(
        "Buffer is too small for COMMAND_COMPLETE event. So will not process.");
    return true;
  }

  PW_MODIFY_DIAGNOSTICS_PUSH();
  PW_MODIFY_DIAGNOSTIC(ignored, "-Wswitch-enum");
  switch (command_complete_event->command_opcode().Read()) {
    case emboss::OpCode::READ_BUFFER_SIZE: {
      Result<emboss::ReadBufferSizeCommandCompleteEventWriter> read_event =
          MakeEmbossWriter<emboss::ReadBufferSizeCommandCompleteEventWriter>(
              hci_buffer);
      if (!read_event.ok()) {
        PW_LOG_ERROR(
            "Buffer is too small for READ_BUFFER_SIZE command complete event. "
            "Will not process.");
        break;
      }
      acl_data_channel_.ProcessReadBufferSizeCommandCompleteEvent(*read_event);
      break;
    }
    case emboss::OpCode::LE_READ_BUFFER_SIZE_V1: {
      Result<emboss::LEReadBufferSizeV1CommandCompleteEventWriter> read_event =
          MakeEmbossWriter<
              emboss::LEReadBufferSizeV1CommandCompleteEventWriter>(hci_buffer);
      if (!read_event.ok()) {
        PW_LOG_ERROR(
            "Buffer is too small for LE_READ_BUFFER_SIZE_V1 command complete "
            "event. So will not process.");
        break;
      }
      acl_data_channel_.ProcessLEReadBufferSizeCommandCompleteEvent(
          *read_event);
      break;
    }
    case emboss::OpCode::LE_READ_BUFFER_SIZE_V2: {
      Result<emboss::LEReadBufferSizeV2CommandCompleteEventWriter> read_event =
          MakeEmbossWriter<
              emboss::LEReadBufferSizeV2CommandCompleteEventWriter>(hci_buffer);
      if (!read_event.ok()) {
        PW_LOG_ERROR(
            "Buffer is too small for LE_READ_BUFFER_SIZE_V2 command complete "
            "event. So will not process.");
        break;
      }
      acl_data_channel_.ProcessLEReadBufferSizeCommandCompleteEvent(
          *read_event);
      break;
    }
    default:
      break;
  }
  PW_MODIFY_DIAGNOSTICS_POP();
  return true;
}

void ProxyHost::HandleCommandFromHost(H4PacketWithH4&& h4_packet) {
  pw::span<uint8_t> hci_buffer = h4_packet.GetHciSpan();
  Result<emboss::GenericHciCommandView> command =
      MakeEmbossView<emboss::GenericHciCommandView>(hci_buffer);
  if (!command.ok()) {
    hci_transport_.SendToController(std::move(h4_packet));
    return;
  }

  if (command->header().opcode().Read() == emboss::OpCode::RESET) {
    PW_LOG_INFO("Resetting proxy on HCI_Reset Command from host.");
    Reset();
  }

  hci_transport_.SendToController(std::move(h4_packet));
}

void ProxyHost::HandleAclFromHost(H4PacketWithH4&& h4_packet) {
  acl_data_channel_.HandleAclFromHost(std::move(h4_packet));
  //  It's possible for a channel handling tx traffic to have queued tx traffic
  //  or events.
  l2cap_channel_manager_.DrainChannelQueuesIfNewTx();
  l2cap_channel_manager_.DeliverPendingEvents();
}

pw::Result<L2capCoc> ProxyHost::DoAcquireL2capCoc(
    multibuf::MultiBufAllocator& rx_multibuf_allocator,
    uint16_t connection_handle,
    L2capCoc::CocConfig rx_config,
    L2capCoc::CocConfig tx_config,
    Function<void(multibuf::MultiBuf&& payload)>&& receive_fn,
    ChannelEventCallback&& event_fn) {
  return l2cap_channel_manager_.AcquireL2capCoc(rx_multibuf_allocator,
                                                connection_handle,
                                                rx_config,
                                                tx_config,
                                                std::move(receive_fn),
                                                std::move(event_fn));
}

pw::Result<BasicL2capChannel> ProxyHost::DoAcquireBasicL2capChannel(
    multibuf::MultiBufAllocator& rx_multibuf_allocator,
    uint16_t connection_handle,
    uint16_t local_cid,
    uint16_t remote_cid,
    AclTransportType transport,
    OptionalPayloadReceiveCallback&& payload_from_controller_fn,
    OptionalPayloadReceiveCallback&& payload_from_host_fn,
    ChannelEventCallback&& event_fn) {
  return l2cap_channel_manager_.AcquireBasicL2capChannel(
      rx_multibuf_allocator,
      connection_handle,
      local_cid,
      remote_cid,
      transport,
      std::move(payload_from_controller_fn),
      std::move(payload_from_host_fn),
      std::move(event_fn));
}

pw::Result<GattNotifyChannel> ProxyHost::DoAcquireGattNotifyChannel(
    int16_t connection_handle,
    uint16_t attribute_handle,
    ChannelEventCallback&& event_fn) {
  return l2cap_channel_manager_.AcquireGattNotifyChannel(
      static_cast<uint16_t>(connection_handle),
      attribute_handle,
      std::move(event_fn));
}

bool ProxyHost::DoHasSendLeAclCapability() const {
  return acl_data_channel_.HasSendAclCapability(AclTransportType::kLe);
}

bool ProxyHost::DoHasSendBrEdrAclCapability() const {
  return acl_data_channel_.HasSendAclCapability(AclTransportType::kBrEdr);
}

uint16_t ProxyHost::DoGetNumFreeLeAclPackets() const {
  return acl_data_channel_.GetNumFreeAclPackets(AclTransportType::kLe);
}

uint16_t ProxyHost::DoGetNumFreeBrEdrAclPackets() const {
  return acl_data_channel_.GetNumFreeAclPackets(AclTransportType::kBrEdr);
}

void ProxyHost::DoRegisterL2capStatusDelegate(L2capStatusDelegate& delegate) {
  l2cap_channel_manager_.RegisterStatusDelegate(delegate);
}

void ProxyHost::DoUnregisterL2capStatusDelegate(L2capStatusDelegate& delegate) {
  l2cap_channel_manager_.UnregisterStatusDelegate(delegate);
}

void ProxyHost::OnConnectionCompleteSuccess(uint16_t connection_handle,
                                            AclTransportType transport) {
  acl_data_channel_.HandleConnectionCompleteEvent(connection_handle, transport);
  Status l2cap_status =
      l2cap_channel_manager_.AddConnection(connection_handle, transport);
  if (!l2cap_status.ok()) {
    PW_LOG_WARN("Could not add L2CAP connection for %#x: %s",
                connection_handle,
                l2cap_status.str());
  }
}

void ProxyHost::OnAclTxCredits() {
  l2cap_channel_manager_.ForceDrainChannelQueues();
}

Result<UniquePtr<ChannelProxy>> ProxyHost::InternalDoInterceptBasicModeChannel(
    ConnectionHandle connection_handle,
    uint16_t local_channel_id,
    uint16_t remote_channel_id,
    AclTransportType transport,
    BufferReceiveFunction&& payload_from_controller_fn,
    BufferReceiveFunction&& payload_from_host_fn,
    ChannelEventCallback&& event_fn) {
  return l2cap_channel_manager_.InterceptBasicModeChannel(
      connection_handle,
      local_channel_id,
      remote_channel_id,
      transport,
      std::move(payload_from_controller_fn),
      std::move(payload_from_host_fn),
      std::move(event_fn));
}

Result<UniquePtr<ChannelProxy>>
ProxyHost::DoInterceptCreditBasedFlowControlChannel(
    ConnectionHandle connection_handle,
    ConnectionOrientedChannelConfig rx_config,
    ConnectionOrientedChannelConfig tx_config,
    MultiBufReceiveFunction&& receive_fn,
    ChannelEventCallback&& event_fn) {
  return l2cap_channel_manager_.InterceptCreditBasedFlowControlChannel(
      connection_handle,
      rx_config,
      tx_config,
      std::move(receive_fn),
      std::move(event_fn));
}

}  // namespace pw::bluetooth::proxy