/*
 * Copyright 2018 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 "BTAudioProviderSessionCodecsDB"

#include "BluetoothAudioSupportedCodecsDB.h"

#include <android-base/logging.h>

namespace android {
namespace bluetooth {
namespace audio {

using ::android::hardware::bluetooth::audio::V2_0::AacObjectType;
using ::android::hardware::bluetooth::audio::V2_0::AacParameters;
using ::android::hardware::bluetooth::audio::V2_0::AacVariableBitRate;
using ::android::hardware::bluetooth::audio::V2_0::AptxParameters;
using ::android::hardware::bluetooth::audio::V2_0::BitsPerSample;
using ::android::hardware::bluetooth::audio::V2_0::ChannelMode;
using ::android::hardware::bluetooth::audio::V2_0::CodecType;
using ::android::hardware::bluetooth::audio::V2_0::LdacChannelMode;
using ::android::hardware::bluetooth::audio::V2_0::LdacParameters;
using ::android::hardware::bluetooth::audio::V2_0::LdacQualityIndex;
using ::android::hardware::bluetooth::audio::V2_0::SampleRate;
using ::android::hardware::bluetooth::audio::V2_0::SbcAllocMethod;
using ::android::hardware::bluetooth::audio::V2_0::SbcBlockLength;
using ::android::hardware::bluetooth::audio::V2_0::SbcChannelMode;
using ::android::hardware::bluetooth::audio::V2_0::SbcNumSubbands;
using ::android::hardware::bluetooth::audio::V2_0::SbcParameters;

// Default Supported PCM Parameters
static const PcmParameters kDefaultSoftwarePcmCapabilities = {
    .sampleRate = static_cast<SampleRate>(
        SampleRate::RATE_44100 | SampleRate::RATE_48000 |
        SampleRate::RATE_88200 | SampleRate::RATE_96000 |
        SampleRate::RATE_16000 | SampleRate::RATE_24000),
    .channelMode =
        static_cast<ChannelMode>(ChannelMode::MONO | ChannelMode::STEREO),
    .bitsPerSample = static_cast<BitsPerSample>(BitsPerSample::BITS_16 |
                                                BitsPerSample::BITS_24 |
                                                BitsPerSample::BITS_32)};

// Default Supported Codecs
// SBC: mSampleRate:(44100), mBitsPerSample:(16), mChannelMode:(MONO|STEREO)
//      all blocks | subbands 8 | Loudness
static const SbcParameters kDefaultOffloadSbcCapability = {
    .sampleRate = SampleRate::RATE_44100,
    .channelMode = static_cast<SbcChannelMode>(SbcChannelMode::MONO |
                                               SbcChannelMode::JOINT_STEREO),
    .blockLength = static_cast<SbcBlockLength>(
        SbcBlockLength::BLOCKS_4 | SbcBlockLength::BLOCKS_8 |
        SbcBlockLength::BLOCKS_12 | SbcBlockLength::BLOCKS_16),
    .numSubbands = SbcNumSubbands::SUBBAND_8,
    .allocMethod = SbcAllocMethod::ALLOC_MD_L,
    .bitsPerSample = BitsPerSample::BITS_16,
    .minBitpool = 2,
    .maxBitpool = 53};

// AAC: mSampleRate:(44100), mBitsPerSample:(16), mChannelMode:(STEREO)
static const AacParameters kDefaultOffloadAacCapability = {
    .objectType = AacObjectType::MPEG2_LC,
    .sampleRate = SampleRate::RATE_44100,
    .channelMode = ChannelMode::STEREO,
    .variableBitRateEnabled = AacVariableBitRate::DISABLED,
    .bitsPerSample = BitsPerSample::BITS_16};

// LDAC: mSampleRate:(44100|48000|88200|96000), mBitsPerSample:(16|24|32),
//       mChannelMode:(DUAL|STEREO)
static const LdacParameters kDefaultOffloadLdacCapability = {
    .sampleRate = static_cast<SampleRate>(
        SampleRate::RATE_44100 | SampleRate::RATE_48000 |
        SampleRate::RATE_88200 | SampleRate::RATE_96000),
    .channelMode = static_cast<LdacChannelMode>(LdacChannelMode::DUAL |
                                                LdacChannelMode::STEREO),
    .qualityIndex = LdacQualityIndex::QUALITY_HIGH,
    .bitsPerSample = static_cast<BitsPerSample>(BitsPerSample::BITS_16 |
                                                BitsPerSample::BITS_24 |
                                                BitsPerSample::BITS_32)};

// aptX: mSampleRate:(44100|48000), mBitsPerSample:(16), mChannelMode:(STEREO)
static const AptxParameters kDefaultOffloadAptxCapability = {
    .sampleRate = static_cast<SampleRate>(SampleRate::RATE_44100 |
                                          SampleRate::RATE_48000),
    .channelMode = ChannelMode::STEREO,
    .bitsPerSample = BitsPerSample::BITS_16,
};

// aptX HD: mSampleRate:(44100|48000), mBitsPerSample:(24),
//          mChannelMode:(STEREO)
static const AptxParameters kDefaultOffloadAptxHdCapability = {
    .sampleRate = static_cast<SampleRate>(SampleRate::RATE_44100 |
                                          SampleRate::RATE_48000),
    .channelMode = ChannelMode::STEREO,
    .bitsPerSample = BitsPerSample::BITS_24,
};

const std::vector<CodecCapabilities> kDefaultOffloadA2dpCodecCapabilities = {
    {.codecType = CodecType::SBC, .capabilities = {}},
    {.codecType = CodecType::AAC, .capabilities = {}},
    {.codecType = CodecType::LDAC, .capabilities = {}},
    {.codecType = CodecType::APTX, .capabilities = {}},
    {.codecType = CodecType::APTX_HD, .capabilities = {}}};

static bool IsSingleBit(uint32_t bitmasks, uint32_t bitfield) {
  bool single = false;
  uint32_t test_bit = 0x00000001;
  while (test_bit <= bitmasks && test_bit <= bitfield) {
    if (bitfield & test_bit && bitmasks & test_bit) {
      if (single) return false;
      single = true;
    }
    if (test_bit == 0x80000000) break;
    test_bit <<= 1;
  }
  return single;
}

static bool IsOffloadSbcConfigurationValid(
    const CodecConfiguration::CodecSpecific& codec_specific);
static bool IsOffloadAacConfigurationValid(
    const CodecConfiguration::CodecSpecific& codec_specific);
static bool IsOffloadLdacConfigurationValid(
    const CodecConfiguration::CodecSpecific& codec_specific);
static bool IsOffloadAptxConfigurationValid(
    const CodecConfiguration::CodecSpecific& codec_specific);
static bool IsOffloadAptxHdConfigurationValid(
    const CodecConfiguration::CodecSpecific& codec_specific);

static bool IsOffloadSbcConfigurationValid(
    const CodecConfiguration::CodecSpecific& codec_specific) {
  if (codec_specific.getDiscriminator() !=
      CodecConfiguration::CodecSpecific::hidl_discriminator::sbcConfig) {
    LOG(WARNING) << __func__
                 << ": Invalid CodecSpecific=" << toString(codec_specific);
    return false;
  }
  const SbcParameters sbc_data = codec_specific.sbcConfig();
  if (!IsSingleBit(static_cast<uint32_t>(sbc_data.sampleRate), 0xff) ||
      !IsSingleBit(static_cast<uint32_t>(sbc_data.channelMode), 0x0f) ||
      !IsSingleBit(static_cast<uint32_t>(sbc_data.blockLength), 0xf0) ||
      !IsSingleBit(static_cast<uint32_t>(sbc_data.numSubbands), 0x0c) ||
      !IsSingleBit(static_cast<uint32_t>(sbc_data.allocMethod), 0x03) ||
      !IsSingleBit(static_cast<uint32_t>(sbc_data.bitsPerSample), 0x07) ||
      sbc_data.minBitpool > sbc_data.maxBitpool) {
    LOG(WARNING) << __func__
                 << ": Invalid CodecSpecific=" << toString(codec_specific);
    return false;
  } else if ((sbc_data.sampleRate & kDefaultOffloadSbcCapability.sampleRate) &&
             (sbc_data.channelMode &
              kDefaultOffloadSbcCapability.channelMode) &&
             (sbc_data.blockLength &
              kDefaultOffloadSbcCapability.blockLength) &&
             (sbc_data.numSubbands &
              kDefaultOffloadSbcCapability.numSubbands) &&
             (sbc_data.allocMethod &
              kDefaultOffloadSbcCapability.allocMethod) &&
             (sbc_data.bitsPerSample &
              kDefaultOffloadSbcCapability.bitsPerSample) &&
             (kDefaultOffloadSbcCapability.minBitpool <= sbc_data.minBitpool &&
              sbc_data.maxBitpool <= kDefaultOffloadSbcCapability.maxBitpool)) {
    return true;
  }
  LOG(WARNING) << __func__
               << ": Unsupported CodecSpecific=" << toString(codec_specific);
  return false;
}

static bool IsOffloadAacConfigurationValid(
    const CodecConfiguration::CodecSpecific& codec_specific) {
  if (codec_specific.getDiscriminator() !=
      CodecConfiguration::CodecSpecific::hidl_discriminator::aacConfig) {
    LOG(WARNING) << __func__
                 << ": Invalid CodecSpecific=" << toString(codec_specific);
    return false;
  }
  const AacParameters aac_data = codec_specific.aacConfig();
  if (!IsSingleBit(static_cast<uint32_t>(aac_data.objectType), 0xf0) ||
      !IsSingleBit(static_cast<uint32_t>(aac_data.sampleRate), 0xff) ||
      !IsSingleBit(static_cast<uint32_t>(aac_data.channelMode), 0x03) ||
      !IsSingleBit(static_cast<uint32_t>(aac_data.bitsPerSample), 0x07)) {
    LOG(WARNING) << __func__
                 << ": Invalid CodecSpecific=" << toString(codec_specific);
    return false;
  } else if ((aac_data.objectType & kDefaultOffloadAacCapability.objectType) &&
             (aac_data.sampleRate & kDefaultOffloadAacCapability.sampleRate) &&
             (aac_data.channelMode &
              kDefaultOffloadAacCapability.channelMode) &&
             (aac_data.variableBitRateEnabled == AacVariableBitRate::DISABLED ||
              kDefaultOffloadAacCapability.variableBitRateEnabled ==
                  AacVariableBitRate::ENABLED) &&
             (aac_data.bitsPerSample &
              kDefaultOffloadAacCapability.bitsPerSample)) {
    return true;
  }
  LOG(WARNING) << __func__
               << ": Unsupported CodecSpecific=" << toString(codec_specific);
  return false;
}

static bool IsOffloadLdacConfigurationValid(
    const CodecConfiguration::CodecSpecific& codec_specific) {
  if (codec_specific.getDiscriminator() !=
      CodecConfiguration::CodecSpecific::hidl_discriminator::ldacConfig) {
    LOG(WARNING) << __func__
                 << ": Invalid CodecSpecific=" << toString(codec_specific);
    return false;
  }
  const LdacParameters ldac_data = codec_specific.ldacConfig();
  if (!IsSingleBit(static_cast<uint32_t>(ldac_data.sampleRate), 0xff) ||
      !IsSingleBit(static_cast<uint32_t>(ldac_data.channelMode), 0x07) ||
      (ldac_data.qualityIndex > LdacQualityIndex::QUALITY_LOW &&
       ldac_data.qualityIndex != LdacQualityIndex::QUALITY_ABR) ||
      !IsSingleBit(static_cast<uint32_t>(ldac_data.bitsPerSample), 0x07)) {
    LOG(WARNING) << __func__
                 << ": Invalid CodecSpecific=" << toString(codec_specific);
    return false;
  } else if ((ldac_data.sampleRate &
              kDefaultOffloadLdacCapability.sampleRate) &&
             (ldac_data.channelMode &
              kDefaultOffloadLdacCapability.channelMode) &&
             (ldac_data.bitsPerSample &
              kDefaultOffloadLdacCapability.bitsPerSample)) {
    return true;
  }
  LOG(WARNING) << __func__
               << ": Unsupported CodecSpecific=" << toString(codec_specific);
  return false;
}

static bool IsOffloadAptxConfigurationValid(
    const CodecConfiguration::CodecSpecific& codec_specific) {
  if (codec_specific.getDiscriminator() !=
      CodecConfiguration::CodecSpecific::hidl_discriminator::aptxConfig) {
    LOG(WARNING) << __func__
                 << ": Invalid CodecSpecific=" << toString(codec_specific);
    return false;
  }
  const AptxParameters aptx_data = codec_specific.aptxConfig();
  if (!IsSingleBit(static_cast<uint32_t>(aptx_data.sampleRate), 0xff) ||
      !IsSingleBit(static_cast<uint32_t>(aptx_data.channelMode), 0x03) ||
      !IsSingleBit(static_cast<uint32_t>(aptx_data.bitsPerSample), 0x07)) {
    LOG(WARNING) << __func__
                 << ": Invalid CodecSpecific=" << toString(codec_specific);
    return false;
  } else if ((aptx_data.sampleRate &
              kDefaultOffloadAptxCapability.sampleRate) &&
             (aptx_data.channelMode &
              kDefaultOffloadAptxCapability.channelMode) &&
             (aptx_data.bitsPerSample &
              kDefaultOffloadAptxCapability.bitsPerSample)) {
    return true;
  }
  LOG(WARNING) << __func__
               << ": Unsupported CodecSpecific=" << toString(codec_specific);
  return false;
}

static bool IsOffloadAptxHdConfigurationValid(
    const CodecConfiguration::CodecSpecific& codec_specific) {
  if (codec_specific.getDiscriminator() !=
      CodecConfiguration::CodecSpecific::hidl_discriminator::aptxConfig) {
    LOG(WARNING) << __func__
                 << ": Invalid CodecSpecific=" << toString(codec_specific);
    return false;
  }
  const AptxParameters aptx_data = codec_specific.aptxConfig();
  if (!IsSingleBit(static_cast<uint32_t>(aptx_data.sampleRate), 0xff) ||
      !IsSingleBit(static_cast<uint32_t>(aptx_data.channelMode), 0x03) ||
      !IsSingleBit(static_cast<uint32_t>(aptx_data.bitsPerSample), 0x07)) {
    LOG(WARNING) << __func__
                 << ": Invalid CodecSpecific=" << toString(codec_specific);
    return false;
  } else if ((aptx_data.sampleRate &
              kDefaultOffloadAptxHdCapability.sampleRate) &&
             (aptx_data.channelMode &
              kDefaultOffloadAptxHdCapability.channelMode) &&
             (aptx_data.bitsPerSample &
              kDefaultOffloadAptxHdCapability.bitsPerSample)) {
    return true;
  }
  LOG(WARNING) << __func__
               << ": Unsupported CodecSpecific=" << toString(codec_specific);
  return false;
}

std::vector<PcmParameters> GetSoftwarePcmCapabilities() {
  return std::vector<PcmParameters>(1, kDefaultSoftwarePcmCapabilities);
}

std::vector<CodecCapabilities> GetOffloadCodecCapabilities(
    const SessionType& session_type) {
  if (session_type != SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH) {
    return std::vector<CodecCapabilities>(0);
  }
  std::vector<CodecCapabilities> offload_a2dp_codec_capabilities =
      kDefaultOffloadA2dpCodecCapabilities;
  for (auto& codec_capability : offload_a2dp_codec_capabilities) {
    switch (codec_capability.codecType) {
      case CodecType::SBC:
        codec_capability.capabilities.sbcCapabilities(
            kDefaultOffloadSbcCapability);
        break;
      case CodecType::AAC:
        codec_capability.capabilities.aacCapabilities(
            kDefaultOffloadAacCapability);
        break;
      case CodecType::LDAC:
        codec_capability.capabilities.ldacCapabilities(
            kDefaultOffloadLdacCapability);
        break;
      case CodecType::APTX:
        codec_capability.capabilities.aptxCapabilities(
            kDefaultOffloadAptxCapability);
        break;
      case CodecType::APTX_HD:
        codec_capability.capabilities.aptxCapabilities(
            kDefaultOffloadAptxHdCapability);
        break;
      case CodecType::UNKNOWN:
        codec_capability = {};
        break;
    }
  }
  return offload_a2dp_codec_capabilities;
}

bool IsSoftwarePcmConfigurationValid(const PcmParameters& pcm_config) {
  if ((pcm_config.sampleRate != SampleRate::RATE_44100 &&
       pcm_config.sampleRate != SampleRate::RATE_48000 &&
       pcm_config.sampleRate != SampleRate::RATE_88200 &&
       pcm_config.sampleRate != SampleRate::RATE_96000 &&
       pcm_config.sampleRate != SampleRate::RATE_16000 &&
       pcm_config.sampleRate != SampleRate::RATE_24000) ||
      (pcm_config.bitsPerSample != BitsPerSample::BITS_16 &&
       pcm_config.bitsPerSample != BitsPerSample::BITS_24 &&
       pcm_config.bitsPerSample != BitsPerSample::BITS_32) ||
      (pcm_config.channelMode != ChannelMode::MONO &&
       pcm_config.channelMode != ChannelMode::STEREO)) {
    LOG(WARNING) << __func__
                 << ": Invalid PCM Configuration=" << toString(pcm_config);
    return false;
  } else if (pcm_config.sampleRate &
                 kDefaultSoftwarePcmCapabilities.sampleRate &&
             pcm_config.bitsPerSample &
                 kDefaultSoftwarePcmCapabilities.bitsPerSample &&
             pcm_config.channelMode &
                 kDefaultSoftwarePcmCapabilities.channelMode) {
    return true;
  }
  LOG(WARNING) << __func__
               << ": Unsupported PCM Configuration=" << toString(pcm_config);
  return false;
}

bool IsOffloadCodecConfigurationValid(const SessionType& session_type,
                                      const CodecConfiguration& codec_config) {
  if (session_type != SessionType::A2DP_HARDWARE_OFFLOAD_DATAPATH) {
    LOG(ERROR) << __func__
               << ": Invalid SessionType=" << toString(session_type);
    return false;
  } else if (codec_config.encodedAudioBitrate < 0x00000001 ||
             0x00ffffff < codec_config.encodedAudioBitrate) {
    LOG(ERROR) << __func__ << ": Unsupported Codec Configuration="
               << toString(codec_config);
    return false;
  }
  const CodecConfiguration::CodecSpecific& codec_specific = codec_config.config;
  switch (codec_config.codecType) {
    case CodecType::SBC:
      if (IsOffloadSbcConfigurationValid(codec_specific)) {
        return true;
      }
      return false;
    case CodecType::AAC:
      if (IsOffloadAacConfigurationValid(codec_specific)) {
        return true;
      }
      return false;
    case CodecType::LDAC:
      if (IsOffloadLdacConfigurationValid(codec_specific)) {
        return true;
      }
      return false;
    case CodecType::APTX:
      if (IsOffloadAptxConfigurationValid(codec_specific)) {
        return true;
      }
      return false;
    case CodecType::APTX_HD:
      if (IsOffloadAptxHdConfigurationValid(codec_specific)) {
        return true;
      }
      return false;
    case CodecType::UNKNOWN:
      return false;
  }
  return false;
}

}  // namespace audio
}  // namespace bluetooth
}  // namespace android