// 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_assert/check.h"  // IWYU pragma: keep
#include "pw_bluetooth/hci_common.emb.h"
#include "pw_bluetooth/hci_h4.emb.h"
#include "pw_bluetooth_proxy/emboss_util.h"
#include "pw_bluetooth_proxy/h4_packet.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)
    : hci_transport_(std::move(send_to_host_fn),
                     std::move(send_to_controller_fn)),
      acl_data_channel_(hci_transport_, le_acl_credits_to_reserve),
      acl_send_pending_(false) {}

void ProxyHost::HandleH4HciFromHost(H4PacketWithH4&& h4_packet) {
  hci_transport_.SendToController(std::move(h4_packet));
}

void ProxyHost::ProcessH4HciFromController(pw::span<uint8_t> hci_buffer) {
  auto event = MakeEmboss<emboss::EventHeaderView>(hci_buffer);
  if (!event.IsComplete()) {
    PW_LOG_ERROR("Buffer is too small for EventHeader. So will not process.");
    return;
  }

  PW_MODIFY_DIAGNOSTICS_PUSH();
  PW_MODIFY_DIAGNOSTIC(ignored, "-Wswitch-enum");
  switch (event.event_code_enum().Read()) {
    case emboss::EventCode::NUMBER_OF_COMPLETED_PACKETS: {
      auto nocp_event =
          MakeEmboss<emboss::NumberOfCompletedPacketsEventWriter>(hci_buffer);
      if (!nocp_event.IsComplete()) {
        PW_LOG_ERROR(
            "Buffer is too small for NUMBER_OF_COMPLETED_PACKETS event. So "
            "will not process.");
        break;
      }
      acl_data_channel_.ProcessNumberOfCompletedPacketsEvent(nocp_event);
      break;
    }
    case emboss::EventCode::DISCONNECTION_COMPLETE: {
      auto dc_event =
          MakeEmboss<emboss::DisconnectionCompleteEventWriter>(hci_buffer);
      if (!dc_event.IsComplete()) {
        PW_LOG_ERROR(
            "Buffer is too small for DISCONNECTION_COMPLETE event. So will not "
            "process.");
        break;
      }
      acl_data_channel_.ProcessDisconnectionCompleteEvent(dc_event);
      break;
    }
    case emboss::EventCode::COMMAND_COMPLETE: {
      ProcessCommandCompleteEvent(hci_buffer);
      break;
    }
    default: {
      PW_LOG_ERROR("Received unexpected HCI event. So will not process.");
      return;
    }
  }
  PW_MODIFY_DIAGNOSTICS_POP();
}

void ProxyHost::ProcessCommandCompleteEvent(pw::span<uint8_t> hci_buffer) {
  auto command_complete_event =
      MakeEmboss<emboss::CommandCompleteEventView>(hci_buffer);
  if (!command_complete_event.IsComplete()) {
    PW_LOG_ERROR(
        "Buffer is too small for COMMAND_COMPLETE event. So will not process.");
    return;
  }

  PW_MODIFY_DIAGNOSTICS_PUSH();
  PW_MODIFY_DIAGNOSTIC(ignored, "-Wswitch-enum");
  switch (command_complete_event.command_opcode_enum().Read()) {
    case emboss::OpCode::LE_READ_BUFFER_SIZE_V1: {
      auto read_event =
          MakeEmboss<emboss::LEReadBufferSizeV1CommandCompleteEventWriter>(
              hci_buffer);
      if (!read_event.IsComplete()) {
        PW_LOG_ERROR(
            "Buffer is too small for LE_READ_BUFFER_SIZE_V1 command complete "
            "event. So will not process.");
        return;
      }
      acl_data_channel_.ProcessLEReadBufferSizeCommandCompleteEvent(read_event);
      break;
    }
    case emboss::OpCode::LE_READ_BUFFER_SIZE_V2: {
      auto read_event =
          MakeEmboss<emboss::LEReadBufferSizeV2CommandCompleteEventWriter>(
              hci_buffer);
      if (!read_event.IsComplete()) {
        PW_LOG_ERROR(
            "Buffer is too small for LE_READ_BUFFER_SIZE_V2 command complete "
            "event. So will not process.");
        return;
      }
      acl_data_channel_.ProcessLEReadBufferSizeCommandCompleteEvent(read_event);
      break;
    }
    default:
      // Nothing to process
      break;
  }
  PW_MODIFY_DIAGNOSTICS_POP();
}

void ProxyHost::HandleH4HciFromController(H4PacketWithHci&& h4_packet) {
  if (h4_packet.GetHciSpan().empty()) {
    PW_LOG_ERROR("Received empty H4 buffer. So will not process.");
  } else if (h4_packet.GetH4Type() == emboss::H4PacketType::EVENT) {
    ProcessH4HciFromController(h4_packet.GetHciSpan());
  }
  hci_transport_.SendToHost(std::move(h4_packet));
}

pw::Status ProxyHost::sendGattNotify(uint16_t connection_handle,
                                     uint16_t attribute_handle,
                                     const pw::span<uint8_t> attribute_value) {
  if (connection_handle > 0x0EFF) {
    PW_LOG_ERROR(
        "Invalid connection handle: %d (max: 0x0EFF). So will not process.",
        connection_handle);
    return pw::Status::InvalidArgument();
  }
  if (attribute_handle == 0) {
    PW_LOG_ERROR("Attribute handle cannot be 0. So will not process.");
    return pw::Status::InvalidArgument();
  }
  if (constexpr uint16_t kMaxAttributeSize =
          kH4BuffSize - 1 - emboss::AttNotifyOverAcl::MinSizeInBytes();
      attribute_value.size() > kMaxAttributeSize) {
    PW_LOG_ERROR("Attribute too large (%zu > %d). So will not process.",
                 attribute_value.size(),
                 kMaxAttributeSize);
    return pw::Status::InvalidArgument();
  }

  H4PacketWithH4 h4_att_notify({});
  {
    std::lock_guard lock(acl_send_mutex_);
    // TODO: https://pwbug.dev/348680331 - Currently ProxyHost only supports 1
    // in-flight ACL send, increase this to support multiple.
    if (acl_send_pending_) {
      return pw::Status::Unavailable();
    }
    acl_send_pending_ = true;

    size_t acl_packet_size =
        emboss::AttNotifyOverAcl::MinSizeInBytes() + attribute_value.size();
    emboss::AttNotifyOverAclWriter att_notify =
        emboss::MakeAttNotifyOverAclView(attribute_value.size(),
                                         H4HciSubspan(h4_buff_).data(),
                                         acl_packet_size);
    if (!att_notify.IsComplete()) {
      PW_LOG_ERROR("Buffer is too small for ATT Notify. So will not send.");
      return pw::Status::InvalidArgument();
    }

    BuildAttNotify(
        att_notify, connection_handle, attribute_handle, attribute_value);

    size_t h4_packet_size = 1 + acl_packet_size;
    H4PacketWithH4 h4_temp(pw::span(h4_buff_.data(), h4_packet_size),
                           [this](const uint8_t* buffer) {
                             std::lock_guard inner_lock(acl_send_mutex_);
                             PW_CHECK_PTR_EQ(
                                 buffer,
                                 h4_buff_.data(),
                                 "Received release callback for buffer that "
                                 "doesn't match our buffer.");
                             PW_LOG_DEBUG("H4 packet release fn called.");
                             acl_send_pending_ = false;
                           });
    h4_temp.SetH4Type(emboss::H4PacketType::ACL_DATA);
    h4_att_notify = std::move(h4_temp);
  }

  // H4 packet is hereby moved. Either ACL data channel will move packet to
  // controller or will be unable to send packet. In either case, packet will be
  // destructed, so its release function will clear the `acl_send_pending` flag.
  if (!acl_data_channel_.SendAcl(std::move(h4_att_notify))) {
    return pw::Status::Unavailable();
  }
  return OkStatus();
}

void ProxyHost::BuildAttNotify(emboss::AttNotifyOverAclWriter att_notify,
                               uint16_t connection_handle,
                               uint16_t attribute_handle,
                               const pw::span<uint8_t> attribute_value) {
  // ACL header
  att_notify.acl_header().handle().Write(connection_handle);
  att_notify.acl_header().packet_boundary_flag().Write(
      emboss::AclDataPacketBoundaryFlag::FIRST_NON_FLUSHABLE);
  att_notify.acl_header().broadcast_flag().Write(
      emboss::AclDataPacketBroadcastFlag::POINT_TO_POINT);
  size_t att_pdu_size =
      emboss::AttHandleValueNtf::MinSizeInBytes() + attribute_value.size();
  att_notify.acl_header().data_total_length().Write(
      emboss::BFrameHeader::IntrinsicSizeInBytes() + att_pdu_size);

  // L2CAP header
  // TODO: https://pwbug.dev/349602172 - Define ATT CID in pw_bluetooth.
  constexpr uint16_t kAttributeProtocolCID = 0x0004;
  att_notify.l2cap_header().channel_id().Write(kAttributeProtocolCID);
  att_notify.l2cap_header().pdu_length().Write(att_pdu_size);

  // ATT PDU
  att_notify.att_handle_value_ntf().attribute_opcode().Write(
      emboss::AttOpcode::ATT_HANDLE_VALUE_NTF);
  att_notify.att_handle_value_ntf().attribute_handle().Write(attribute_handle);
  std::memcpy(att_notify.att_handle_value_ntf()
                  .attribute_value()
                  .BackingStorage()
                  .data(),
              attribute_value.data(),
              attribute_value.size());
}

bool ProxyHost::HasSendAclCapability() const {
  return acl_data_channel_.GetLeAclCreditsToReserve() > 0;
}

uint16_t ProxyHost::GetNumFreeLeAclPackets() const {
  return acl_data_channel_.GetNumFreeLeAclPackets();
}

}  // namespace pw::bluetooth::proxy