//
//  Copyright (C) 2017 Google, Inc.
//
//  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 "service/a2dp_source.h"

#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "service/logging_helpers.h"

#define PARSE_ADDR(str)                                        \
  ({                                                           \
    RawAddress tmp;                                            \
    if (!RawAddress::FromString((str), tmp)) {                 \
      LOG(ERROR) << "Invalid device address given: " << (str); \
      return false;                                            \
    }                                                          \
    tmp;                                                       \
  })

#define TRY_RET(expr, err_msg) \
  do {                         \
    if (!(expr)) {             \
      LOG(ERROR) << err_msg;   \
      return false;            \
    }                          \
    return true;               \
  } while (0)

#define TRY_RET_FUNC(expr) TRY_RET(expr, __func__ << " failed")

using bluetooth::hal::BluetoothAvInterface;
using LockGuard = std::lock_guard<std::mutex>;

namespace bluetooth {

namespace {

btav_a2dp_codec_config_t CodecConfigToFluoride(const A2dpCodecConfig& config) {
  btav_a2dp_codec_config_t ret = {
      .codec_type = static_cast<btav_a2dp_codec_index_t>(config.codec_type()),
      .codec_priority =
          static_cast<btav_a2dp_codec_priority_t>(config.codec_priority()),
      .sample_rate =
          static_cast<btav_a2dp_codec_sample_rate_t>(config.sample_rate()),
      .bits_per_sample = static_cast<btav_a2dp_codec_bits_per_sample_t>(
          config.bits_per_sample()),
      .channel_mode =
          static_cast<btav_a2dp_codec_channel_mode_t>(config.channel_mode()),
      .codec_specific_1 = config.codec_specific_1(),
      .codec_specific_2 = config.codec_specific_2(),
      .codec_specific_3 = config.codec_specific_3(),
      .codec_specific_4 = config.codec_specific_4(),
  };

  return ret;
}

std::vector<btav_a2dp_codec_config_t> CodecConfigsToFluoride(
    const std::vector<A2dpCodecConfig>& configs) {
  std::vector<btav_a2dp_codec_config_t> ret;
  ret.reserve(configs.size());
  for (const auto& config : configs) {
    ret.push_back(CodecConfigToFluoride(config));
  }

  return ret;
}
A2dpCodecConfig FluorideCodecToCodec(const btav_a2dp_codec_config_t& config) {
  A2dpCodecConfig ret(config.codec_type, config.codec_priority,
                      config.sample_rate, config.bits_per_sample,
                      config.channel_mode, config.codec_specific_1,
                      config.codec_specific_2, config.codec_specific_3,
                      config.codec_specific_4);

  return ret;
}

std::vector<A2dpCodecConfig> FluorideCodecsToCodec(
    const std::vector<btav_a2dp_codec_config_t>& configs) {
  std::vector<A2dpCodecConfig> ret;
  ret.reserve(configs.size());
  for (const auto& config : configs) {
    ret.push_back(FluorideCodecToCodec(config));
  }

  return ret;
}

}  // namespace

// static
const int A2dpSource::kSingletonInstanceId = 0;

A2dpSource::A2dpSource(const Uuid& uuid) : app_identifier_(uuid) {
  hal::BluetoothAvInterface::Get()->AddA2dpSourceObserver(this);
}

A2dpSource::~A2dpSource() {
  hal::BluetoothAvInterface::Get()->RemoveA2dpSourceObserver(this);
}

const Uuid& A2dpSource::GetAppIdentifier() const { return app_identifier_; }

int A2dpSource::GetInstanceId() const { return kSingletonInstanceId; }

void A2dpSource::SetDelegate(Delegate* delegate) {
  LockGuard lock(delegate_mutex_);
  delegate_ = delegate;
}

bool A2dpSource::Enable(const std::vector<A2dpCodecConfig>& codec_priorities) {
  auto fluoride_priorities = CodecConfigsToFluoride(codec_priorities);
  LockGuard lock(mutex_);
  return hal::BluetoothAvInterface::Get()->A2dpSourceEnable(
      fluoride_priorities);
}

void A2dpSource::Disable() {
  LockGuard lock(mutex_);
  hal::BluetoothAvInterface::Get()->A2dpSourceDisable();
}

bool A2dpSource::Connect(const std::string& device_address) {
  RawAddress addr = PARSE_ADDR(device_address);
  LockGuard lock(mutex_);
  TRY_RET_FUNC(
      hal::BluetoothAvInterface::Get()->GetA2dpSourceHALInterface()->connect(
          addr) == BT_STATUS_SUCCESS);
}

bool A2dpSource::Disconnect(const std::string& device_address) {
  RawAddress addr = PARSE_ADDR(device_address);
  LockGuard lock(mutex_);
  TRY_RET_FUNC(
      hal::BluetoothAvInterface::Get()->GetA2dpSourceHALInterface()->disconnect(
          addr) == BT_STATUS_SUCCESS);
}

bool A2dpSource::ConfigCodec(
    const std::string& device_address,
    const std::vector<A2dpCodecConfig>& codec_preferences) {
  RawAddress addr = PARSE_ADDR(device_address);
  auto fluoride_preferences = CodecConfigsToFluoride(codec_preferences);
  LockGuard lock(mutex_);
  TRY_RET_FUNC(hal::BluetoothAvInterface::Get()
                   ->GetA2dpSourceHALInterface()
                   ->config_codec(addr, fluoride_preferences) ==
               BT_STATUS_SUCCESS);
}

void A2dpSource::ConnectionStateCallback(BluetoothAvInterface* iface,
                                         const RawAddress& bd_addr,
                                         btav_connection_state_t state) {
  auto device_address = BtAddrString(&bd_addr);
  LockGuard lock(delegate_mutex_);
  if (delegate_)
    delegate_->OnConnectionState(device_address, static_cast<int>(state));
}

void A2dpSource::AudioStateCallback(BluetoothAvInterface* iface,
                                    const RawAddress& bd_addr,
                                    btav_audio_state_t state) {
  auto device_address = BtAddrString(&bd_addr);
  LockGuard lock(delegate_mutex_);
  if (delegate_)
    delegate_->OnAudioState(device_address, static_cast<int>(state));
}

void A2dpSource::AudioConfigCallback(
    BluetoothAvInterface* iface, const RawAddress& bd_addr,
    const btav_a2dp_codec_config_t& codec_config_fluoride,
    const std::vector<btav_a2dp_codec_config_t>
        codecs_local_capabilities_fluoride,
    const std::vector<btav_a2dp_codec_config_t>
        codecs_selectable_capabilities_fluoride) {
  auto device_address = BtAddrString(&bd_addr);
  auto codec_config = FluorideCodecToCodec(codec_config_fluoride);
  auto codecs_local_capabilities =
      FluorideCodecsToCodec(codecs_local_capabilities_fluoride);
  auto codecs_selectable_capabilities =
      FluorideCodecsToCodec(codecs_selectable_capabilities_fluoride);
  LockGuard lock(delegate_mutex_);
  if (delegate_)
    delegate_->OnAudioConfig(device_address, codec_config,
                             codecs_local_capabilities,
                             codecs_selectable_capabilities);
}

// A2dpSourceFactory implementation
// ========================================================
A2dpSourceFactory::A2dpSourceFactory() = default;
A2dpSourceFactory::~A2dpSourceFactory() = default;

bool A2dpSourceFactory::RegisterInstance(const Uuid& uuid,
                                         const RegisterCallback& callback) {
  VLOG(1) << __func__ << " - UUID: " << uuid.ToString();

  auto a2dp_source = base::WrapUnique(new A2dpSource(uuid));
  callback(BLE_STATUS_SUCCESS, uuid, std::move(a2dp_source));
  return true;
}

}  // namespace bluetooth