/*
 * Copyright 2019 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.
 */

#define LOG_TAG "bt_shim_controller"

#include "main/shim/controller.h"

#include "btcore/include/module.h"
#include "gd/common/init_flags.h"
#include "hci/controller.h"
#include "main/shim/entry.h"
#include "main/shim/shim.h"
#include "main/shim/stack.h"
#include "osi/include/future.h"
#include "osi/include/log.h"
#include "src/bridge.rs.h"
#include "types/raw_address.h"

using ::bluetooth::common::init_flags::gd_rust_is_enabled;
using ::bluetooth::shim::GetController;

constexpr int kMaxSupportedCodecs = 8;  // MAX_LOCAL_SUPPORTED_CODECS_SIZE

constexpr uint8_t kPhyLe1M = 0x01;

/**
 * Interesting commands supported by controller
 */
constexpr int kReadRemoteExtendedFeatures = 0x41c;
constexpr int kEnhancedSetupSynchronousConnection = 0x428;
constexpr int kEnhancedAcceptSynchronousConnection = 0x429;
constexpr int kLeSetPrivacyMode = 0x204e;

constexpr int kHciDataPreambleSize = 4;  // #define HCI_DATA_PREAMBLE_SIZE 4

// Module lifecycle functions
static future_t* start_up(void);
static future_t* shut_down(void);

EXPORT_SYMBOL extern const module_t gd_controller_module = {
    .name = GD_CONTROLLER_MODULE,
    .init = nullptr,
    .start_up = start_up,
    .shut_down = shut_down,
    .clean_up = nullptr,
    .dependencies = {GD_SHIM_MODULE, nullptr}};

struct {
  bool ready;
  RawAddress raw_address;
  bt_version_t bt_version;
  uint8_t local_supported_codecs[kMaxSupportedCodecs];
  uint8_t number_of_local_supported_codecs;
  uint64_t le_supported_states;
  uint8_t phy;
} data_;

static future_t* start_up(void) {
  LOG_INFO("%s Starting up", __func__);
  data_.ready = true;

  if (gd_rust_is_enabled()) {
    auto controller =
        bluetooth::shim::Stack::GetInstance()->GetRustController();
    auto rust_string_address =
        bluetooth::shim::rust::controller_get_address(**controller);
    auto string_address =
        std::string(rust_string_address.data(), rust_string_address.length());
    RawAddress::FromString(string_address, data_.raw_address);

    data_.le_supported_states =
        bluetooth::shim::rust::controller_get_le_supported_states(**controller);

    LOG_INFO("Mac address:%s", string_address.c_str());
  } else {
    std::string string_address = GetController()->GetMacAddress().ToString();
    RawAddress::FromString(string_address, data_.raw_address);

    data_.le_supported_states =
        bluetooth::shim::GetController()->GetLeSupportedStates();

    auto local_version_info =
        bluetooth::shim::GetController()->GetLocalVersionInformation();
    data_.bt_version.hci_version =
        static_cast<uint8_t>(local_version_info.hci_version_);
    data_.bt_version.hci_revision = local_version_info.hci_revision_;
    data_.bt_version.lmp_version =
        static_cast<uint8_t>(local_version_info.lmp_version_);
    data_.bt_version.lmp_subversion = local_version_info.lmp_subversion_;
    data_.bt_version.manufacturer = local_version_info.manufacturer_name_;

    LOG_INFO("Mac address:%s", string_address.c_str());
  }

  data_.phy = kPhyLe1M;

  return future_new_immediate(FUTURE_SUCCESS);
}

static future_t* shut_down(void) {
  data_.ready = false;
  return future_new_immediate(FUTURE_SUCCESS);
}

/**
 * Module methods
 */

static bool get_is_ready(void) { return data_.ready; }

static const RawAddress* get_address(void) { return &data_.raw_address; }

static const bt_version_t* get_bt_version(void) { return &data_.bt_version; }

static uint8_t* get_local_supported_codecs(uint8_t* number_of_codecs) {
  CHECK(number_of_codecs != nullptr);
  if (data_.number_of_local_supported_codecs != 0) {
    *number_of_codecs = data_.number_of_local_supported_codecs;
    return data_.local_supported_codecs;
  }
  return (uint8_t*)nullptr;
}

static const uint8_t* get_ble_supported_states(void) {
  return (const uint8_t*)&data_.le_supported_states;
}

#define MAP_TO_GD(legacy, gd)                                            \
  static bool legacy(void) {                                             \
    if (gd_rust_is_enabled()) {                                          \
      return bluetooth::shim::rust::controller_##legacy(                 \
          **bluetooth::shim::Stack::GetInstance()->GetRustController()); \
    } else {                                                             \
      return GetController()->gd();                                      \
    }                                                                    \
  }

MAP_TO_GD(supports_simple_pairing, SupportsSimplePairing)
MAP_TO_GD(supports_secure_connections, SupportsSecureConnections)
MAP_TO_GD(supports_simultaneous_le_bredr, SupportsSimultaneousLeBrEdr)
MAP_TO_GD(supports_interlaced_inquiry_scan, SupportsInterlacedInquiryScan)
MAP_TO_GD(supports_rssi_with_inquiry_results, SupportsRssiWithInquiryResults)
MAP_TO_GD(supports_extended_inquiry_response, SupportsExtendedInquiryResponse)
MAP_TO_GD(supports_three_slot_packets, Supports3SlotPackets)
MAP_TO_GD(supports_five_slot_packets, Supports5SlotPackets)
MAP_TO_GD(supports_classic_2m_phy, SupportsClassic2mPhy)
MAP_TO_GD(supports_classic_3m_phy, SupportsClassic3mPhy)
MAP_TO_GD(supports_three_slot_edr_packets, Supports3SlotEdrPackets)
MAP_TO_GD(supports_five_slot_edr_packets, Supports5SlotEdrPackets)
MAP_TO_GD(supports_sco, SupportsSco)
MAP_TO_GD(supports_hv2_packets, SupportsHv2Packets)
MAP_TO_GD(supports_hv3_packets, SupportsHv3Packets)
MAP_TO_GD(supports_ev3_packets, SupportsEv3Packets)
MAP_TO_GD(supports_ev4_packets, SupportsEv4Packets)
MAP_TO_GD(supports_ev5_packets, SupportsEv5Packets)
MAP_TO_GD(supports_esco_2m_phy, SupportsEsco2mPhy)
MAP_TO_GD(supports_esco_3m_phy, SupportsEsco3mPhy)
MAP_TO_GD(supports_three_slot_esco_edr_packets, Supports3SlotEscoEdrPackets)
MAP_TO_GD(supports_role_switch, SupportsRoleSwitch)
MAP_TO_GD(supports_hold_mode, SupportsHoldMode)
MAP_TO_GD(supports_sniff_mode, SupportsSniffMode)
MAP_TO_GD(supports_park_mode, SupportsParkMode)
MAP_TO_GD(supports_non_flushable_pb, SupportsNonFlushablePb)
MAP_TO_GD(supports_sniff_subrating, SupportsSniffSubrating)
MAP_TO_GD(supports_encryption_pause, SupportsEncryptionPause)

MAP_TO_GD(supports_ble, SupportsBle)
MAP_TO_GD(supports_privacy, SupportsBlePrivacy)
MAP_TO_GD(supports_packet_extension, SupportsBleDataPacketLengthExtension)
MAP_TO_GD(supports_connection_parameters_request,
          SupportsBleConnectionParametersRequest)
MAP_TO_GD(supports_ble_2m_phy, SupportsBle2mPhy)
MAP_TO_GD(supports_ble_coded_phy, SupportsBleCodedPhy)
MAP_TO_GD(supports_extended_advertising, SupportsBleExtendedAdvertising)
MAP_TO_GD(supports_periodic_advertising, SupportsBlePeriodicAdvertising)
MAP_TO_GD(supports_peripheral_initiated_feature_exchange,
          SupportsBlePeripheralInitiatedFeaturesExchange)
MAP_TO_GD(supports_connection_parameter_request,
          SupportsBleConnectionParametersRequest)

MAP_TO_GD(supports_periodic_advertising_sync_transfer_sender,
          SupportsBlePeriodicAdvertisingSyncTransferSender)
MAP_TO_GD(supports_periodic_advertising_sync_transfer_recipient,
          SupportsBlePeriodicAdvertisingSyncTransferRecipient)
MAP_TO_GD(supports_connected_iso_stream_central,
          SupportsBleConnectedIsochronousStreamCentral)
MAP_TO_GD(supports_connected_iso_stream_peripheral,
          SupportsBleConnectedIsochronousStreamPeripheral)
MAP_TO_GD(supports_iso_broadcaster, SupportsBleIsochronousBroadcaster)
MAP_TO_GD(supports_synchronized_receiver, SupportsBleSynchronizedReceiver)

#define FORWARD_IF_RUST(legacy, gd)                                      \
  static bool legacy(void) {                                             \
    if (gd_rust_is_enabled()) {                                          \
      return bluetooth::shim::rust::controller_##legacy(                 \
          **bluetooth::shim::Stack::GetInstance()->GetRustController()); \
    } else {                                                             \
      return gd;                                                         \
    }                                                                    \
  }

FORWARD_IF_RUST(supports_reading_remote_extended_features,
                GetController()->IsSupported((bluetooth::hci::OpCode)
                                                 kReadRemoteExtendedFeatures))
FORWARD_IF_RUST(supports_enhanced_setup_synchronous_connection,
                GetController()->IsSupported((
                    bluetooth::hci::OpCode)kEnhancedSetupSynchronousConnection))
FORWARD_IF_RUST(
    supports_enhanced_accept_synchronous_connection,
    GetController()->IsSupported((bluetooth::hci::OpCode)
                                     kEnhancedAcceptSynchronousConnection))
FORWARD_IF_RUST(
    supports_ble_set_privacy_mode,
    GetController()->IsSupported((bluetooth::hci::OpCode)kLeSetPrivacyMode))

#define FORWARD_GETTER_IF_RUST(type, legacy, gd)                         \
  static type legacy(void) {                                             \
    if (gd_rust_is_enabled()) {                                          \
      return bluetooth::shim::rust::controller_##legacy(                 \
          **bluetooth::shim::Stack::GetInstance()->GetRustController()); \
    } else {                                                             \
      return gd;                                                         \
    }                                                                    \
  }

FORWARD_GETTER_IF_RUST(uint16_t, get_acl_buffer_length,
                       GetController()->GetAclPacketLength())
FORWARD_GETTER_IF_RUST(
    uint16_t, get_le_buffer_length,
    GetController()->GetLeBufferSize().le_data_packet_length_)
FORWARD_GETTER_IF_RUST(
    uint16_t, get_iso_buffer_length,
    GetController()->GetControllerIsoBufferSize().le_data_packet_length_)

static uint16_t get_acl_packet_size_classic(void) {
  return get_acl_buffer_length() + kHciDataPreambleSize;
}

static uint16_t get_acl_packet_size_ble(void) {
  return get_le_buffer_length() + kHciDataPreambleSize;
}

static uint16_t get_iso_packet_size(void) {
  return get_iso_buffer_length() + kHciDataPreambleSize;
}

FORWARD_GETTER_IF_RUST(uint16_t, get_le_suggested_default_data_length,
                       GetController()->GetLeSuggestedDefaultDataLength())

static uint16_t get_le_maximum_tx_data_length(void) {
  if (gd_rust_is_enabled()) {
    return bluetooth::shim::rust::controller_get_le_maximum_tx_data_length(
        **bluetooth::shim::Stack::GetInstance()->GetRustController());
  } else {
    ::bluetooth::hci::LeMaximumDataLength le_maximum_data_length =
        GetController()->GetLeMaximumDataLength();
    return le_maximum_data_length.supported_max_tx_octets_;
  }
}

static uint16_t get_le_maximum_tx_time(void) {
  if (gd_rust_is_enabled()) {
    return bluetooth::shim::rust::controller_get_le_maximum_tx_time(
        **bluetooth::shim::Stack::GetInstance()->GetRustController());
  } else {
    ::bluetooth::hci::LeMaximumDataLength le_maximum_data_length =
        GetController()->GetLeMaximumDataLength();
    return le_maximum_data_length.supported_max_tx_time_;
  }
}

FORWARD_GETTER_IF_RUST(uint16_t, get_le_max_advertising_data_length,
                       GetController()->GetLeMaximumAdvertisingDataLength())
FORWARD_GETTER_IF_RUST(uint8_t, get_le_supported_advertising_sets,
                       GetController()->GetLeNumberOfSupportedAdverisingSets())
FORWARD_GETTER_IF_RUST(uint8_t, get_le_periodic_advertiser_list_size,
                       GetController()->GetLePeriodicAdvertiserListSize())
FORWARD_GETTER_IF_RUST(uint16_t, get_acl_buffers,
                       GetController()->GetNumAclPacketBuffers())
FORWARD_GETTER_IF_RUST(uint8_t, get_le_buffers,
                       GetController()->GetLeBufferSize().total_num_le_packets_)
FORWARD_GETTER_IF_RUST(
    uint8_t, get_iso_buffers,
    GetController()->GetControllerIsoBufferSize().total_num_le_packets_)
FORWARD_GETTER_IF_RUST(uint8_t, get_le_connect_list_size,
                       GetController()->GetLeConnectListSize())

static uint8_t ble_resolving_list_max_size = 0;

static void set_ble_resolving_list_max_size(int resolving_list_max_size) {
  ble_resolving_list_max_size = resolving_list_max_size;
}

static uint8_t get_le_resolving_list_size(void) {
  return ble_resolving_list_max_size;
}

static uint8_t get_le_all_initiating_phys() { return data_.phy; }

static const controller_t interface = {
    get_is_ready,

    get_address,
    get_bt_version,

    get_ble_supported_states,

    supports_simple_pairing,
    supports_secure_connections,
    supports_simultaneous_le_bredr,
    supports_reading_remote_extended_features,
    supports_interlaced_inquiry_scan,
    supports_rssi_with_inquiry_results,
    supports_extended_inquiry_response,
    supports_role_switch,
    supports_enhanced_setup_synchronous_connection,
    supports_enhanced_accept_synchronous_connection,
    supports_three_slot_packets,
    supports_five_slot_packets,
    supports_classic_2m_phy,
    supports_classic_3m_phy,
    supports_three_slot_edr_packets,
    supports_five_slot_edr_packets,
    supports_sco,
    supports_hv2_packets,
    supports_hv3_packets,
    supports_ev3_packets,
    supports_ev4_packets,
    supports_ev5_packets,
    supports_esco_2m_phy,
    supports_esco_3m_phy,
    supports_three_slot_esco_edr_packets,
    supports_role_switch,
    supports_hold_mode,
    supports_sniff_mode,
    supports_park_mode,
    supports_non_flushable_pb,
    supports_sniff_subrating,
    supports_encryption_pause,

    supports_ble,
    supports_packet_extension,
    supports_connection_parameters_request,
    supports_privacy,
    supports_ble_set_privacy_mode,
    supports_ble_2m_phy,
    supports_ble_coded_phy,
    supports_extended_advertising,
    supports_periodic_advertising,
    supports_peripheral_initiated_feature_exchange,
    supports_connection_parameter_request,
    supports_periodic_advertising_sync_transfer_sender,
    supports_periodic_advertising_sync_transfer_recipient,
    supports_connected_iso_stream_central,
    supports_connected_iso_stream_peripheral,
    supports_iso_broadcaster,
    supports_synchronized_receiver,

    get_acl_buffer_length,
    get_le_buffer_length,
    get_iso_buffer_length,

    get_acl_packet_size_classic,
    get_acl_packet_size_ble,
    get_iso_packet_size,
    get_le_suggested_default_data_length,
    get_le_maximum_tx_data_length,
    get_le_maximum_tx_time,
    get_le_max_advertising_data_length,
    get_le_supported_advertising_sets,
    get_le_periodic_advertiser_list_size,

    get_acl_buffers,
    get_le_buffers,
    get_iso_buffers,

    get_le_connect_list_size,

    get_le_resolving_list_size,
    set_ble_resolving_list_max_size,
    get_local_supported_codecs,
    get_le_all_initiating_phys};

const controller_t* bluetooth::shim::controller_get_interface() {
  static bool loaded = false;
  if (!loaded) {
    loaded = true;
  }
  return &interface;
}

void bluetooth::shim::controller_clear_event_mask() {
  bluetooth::shim::GetController()->SetEventMask(0);
}