/*
 * Copyright 2021 HIMSA II K/S - www.himsa.com.
 * Represented by EHIMA - www.ehima.com
 *
 * 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 <base/functional/bind.h>
#include <bluetooth/log.h>
#include <lc3.h>

#include <mutex>

#include "bta/include/bta_le_audio_broadcaster_api.h"
#include "bta/le_audio/broadcaster/state_machine.h"
#include "bta/le_audio/codec_interface.h"
#include "bta/le_audio/content_control_id_keeper.h"
#include "bta/le_audio/le_audio_types.h"
#include "bta/le_audio/le_audio_utils.h"
#include "bta/le_audio/metrics_collector.h"
#include "bta_le_audio_api.h"
#include "common/strings.h"
#include "hci/controller_interface.h"
#include "internal_include/stack_config.h"
#include "main/shim/entry.h"
#include "os/log.h"
#include "osi/include/properties.h"
#include "stack/include/bt_types.h"
#include "stack/include/btm_api_types.h"
#include "stack/include/btm_iso_api.h"

using bluetooth::common::ToString;
using bluetooth::hci::IsoManager;
using bluetooth::hci::iso_manager::big_create_cmpl_evt;
using bluetooth::hci::iso_manager::big_terminate_cmpl_evt;
using bluetooth::hci::iso_manager::BigCallbacks;
using bluetooth::le_audio::BasicAudioAnnouncementData;
using bluetooth::le_audio::BasicAudioAnnouncementSubgroup;
using bluetooth::le_audio::BroadcastId;
using bluetooth::le_audio::CodecManager;
using bluetooth::le_audio::ContentControlIdKeeper;
using bluetooth::le_audio::DsaMode;
using bluetooth::le_audio::LeAudioCodecConfiguration;
using bluetooth::le_audio::LeAudioSourceAudioHalClient;
using bluetooth::le_audio::PublicBroadcastAnnouncementData;
using bluetooth::le_audio::broadcaster::BigConfig;
using bluetooth::le_audio::broadcaster::BroadcastConfiguration;
using bluetooth::le_audio::broadcaster::BroadcastQosConfig;
using bluetooth::le_audio::broadcaster::BroadcastStateMachine;
using bluetooth::le_audio::broadcaster::BroadcastStateMachineConfig;
using bluetooth::le_audio::broadcaster::BroadcastSubgroupCodecConfig;
using bluetooth::le_audio::broadcaster::IBroadcastStateMachineCallbacks;
using bluetooth::le_audio::types::AudioContexts;
using bluetooth::le_audio::types::CodecLocation;
using bluetooth::le_audio::types::kLeAudioCodingFormatLC3;
using bluetooth::le_audio::types::LeAudioContextType;
using bluetooth::le_audio::types::LeAudioLtvMap;
using bluetooth::le_audio::utils::GetAudioContextsFromSourceMetadata;

using namespace bluetooth;

namespace {
class LeAudioBroadcasterImpl;
LeAudioBroadcasterImpl* instance;
std::mutex instance_mutex;

/* Class definitions */

/* LeAudioBroadcasterImpl class represents main implementation class for le
 * audio broadcaster feature in the stack.
 *
 * This class may be bonded with Test socket which allows to drive an instance
 * for test purposes.
 */
class LeAudioBroadcasterImpl : public LeAudioBroadcaster, public BigCallbacks {
  enum class AudioDataPathState {
    INACTIVE,
    ACTIVE,
    SUSPENDED,
  };

 public:
  LeAudioBroadcasterImpl(
      bluetooth::le_audio::LeAudioBroadcasterCallbacks* callbacks_)
      : callbacks_(callbacks_),
        current_phy_(PHY_LE_2M),
        audio_data_path_state_(AudioDataPathState::INACTIVE),
        le_audio_source_hal_client_(nullptr) {
    log::info("");

    /* Register State machine callbacks */
    BroadcastStateMachine::Initialize(&state_machine_callbacks_,
                                      &state_machine_adv_callbacks_);

    GenerateBroadcastIds();
  }

  ~LeAudioBroadcasterImpl() override = default;

  void GenerateBroadcastIds(void) {
    btsnd_hcic_ble_rand(base::Bind([](BT_OCTET8 rand) {
      if (!instance) return;

      /* LE Rand returns 8 octets. Lets' make 2 outstanding Broadcast Ids out
       * of it */
      for (int i = 0; i < 8; i += 4) {
        BroadcastId broadcast_id = 0;
        /* Broadcast ID should be 3 octets long (BAP v1.0 spec.) */
        STREAM_TO_UINT24(broadcast_id, rand);
        if (broadcast_id == bluetooth::le_audio::kBroadcastIdInvalid) continue;
        instance->available_broadcast_ids_.emplace_back(broadcast_id);
      }

      if (instance->available_broadcast_ids_.empty()) {
        log::fatal("Unable to generate proper broadcast identifiers.");
      }
    }));
  }

  void CleanUp() {
    log::info("Broadcaster");
    broadcasts_.clear();
    callbacks_ = nullptr;
    is_iso_running_ = false;

    if (!LeAudioClient::IsLeAudioClientRunning())
      IsoManager::GetInstance()->Stop();

    queued_start_broadcast_request_ = std::nullopt;
    queued_create_broadcast_request_ = std::nullopt;

    if (le_audio_source_hal_client_) {
      le_audio_source_hal_client_->Stop();
      auto result =
          CodecManager::GetInstance()->UpdateActiveBroadcastAudioHalClient(
              le_audio_source_hal_client_.get(), false);
      log::assert_that(result, "Could not update session in codec manager");
      le_audio_source_hal_client_.reset();
    }
  }

  void Stop() {
    log::info("Broadcaster");

    for (auto& sm_pair : broadcasts_) {
      StopAudioBroadcast(sm_pair.first);
    }
  }

  static PublicBroadcastAnnouncementData preparePublicAnnouncement(
      uint8_t features, const LeAudioLtvMap& metadata) {
    PublicBroadcastAnnouncementData announcement;

    /* Prepare the announcement */
    announcement.features = features;
    announcement.metadata = metadata.Values();
    return announcement;
  }

  static BasicAudioAnnouncementData prepareBasicAnnouncement(
      const std::vector<BroadcastSubgroupCodecConfig>& subgroup_configs,
      const std::vector<LeAudioLtvMap>& metadata_group) {
    BasicAudioAnnouncementData announcement;

    /* Prepare the announcement */
    announcement.presentation_delay_us = 40000; /* us */

    log::assert_that(subgroup_configs.size() == metadata_group.size(),
                     "The number of metadata subgroups {} does not match the "
                     "number of subgroup configurations {}.",
                     metadata_group.size(), subgroup_configs.size());

    uint8_t subgroup_idx = 0;
    uint8_t bis_index = 0;
    while (subgroup_idx < subgroup_configs.size() &&
           subgroup_idx < metadata_group.size()) {
      const auto& subgroup_config = subgroup_configs.at(subgroup_idx);
      const auto& metadata = metadata_group.at(subgroup_idx);

      auto const& codec_id = subgroup_config.GetLeAudioCodecId();
      auto const subgroup_codec_spec =
          subgroup_config.GetCommonBisCodecSpecData();
      auto opt_vendor_spec_data = subgroup_config.GetVendorCodecSpecData();

      /* Note: Currently we have a single audio source configured with a one
       *       set of codec/pcm parameters thus we can use a single subgroup
       *       for all the BISes. Configure common BIS codec params at the
       *       subgroup level.
       */
      BasicAudioAnnouncementSubgroup config = {
          .codec_config =
              {
                  .codec_id = codec_id.coding_format,
                  .vendor_company_id = codec_id.vendor_company_id,
                  .vendor_codec_id = codec_id.vendor_codec_id,
                  .codec_specific_params =
                      opt_vendor_spec_data.has_value()
                          ? std::map<uint8_t, std::vector<uint8_t>>{}
                          : subgroup_codec_spec.Values(),
                  .vendor_codec_specific_params =
                      std::move(opt_vendor_spec_data),
              },
          .metadata = metadata.Values(),
          .bis_configs = {},
      };

      for (uint8_t bis_cfg_idx = 0;
           bis_cfg_idx < subgroup_config.GetAllBisConfigCount();
           ++bis_cfg_idx) {
        auto bis_cfg_num_of_bises = subgroup_config.GetNumBis(bis_cfg_idx);
        for (uint8_t bis_num = 0; bis_num < bis_cfg_num_of_bises; ++bis_num) {
          // Internally BISes are indexed from 0 in each subgroup, but the BT
          // spec requires the indices to start from 1 in the entire BIG.
          ++bis_index;

          // Check for vendor byte array
          bluetooth::le_audio::BasicAudioAnnouncementBisConfig bis_config;
          auto vendor_config =
              subgroup_config.GetBisVendorCodecSpecData(bis_num);
          if (vendor_config) {
            bis_config.vendor_codec_specific_params = vendor_config.value();
          }

          // Check for non vendor LTVs
          auto config_ltv =
              subgroup_config.GetBisCodecSpecData(bis_num, bis_cfg_idx);
          if (config_ltv) {
            // Remove the part which is common with the parent subgroup
            // parameters
            config_ltv->RemoveAllTypes(subgroup_codec_spec);
            bis_config.codec_specific_params = config_ltv->Values();
          }

          bis_config.bis_index = bis_index;
          config.bis_configs.push_back(std::move(bis_config));
        }
      }

      announcement.subgroup_configs.push_back(config);
      ++subgroup_idx;
    }

    return announcement;
  }

  void UpdateStreamingContextTypeOnAllSubgroups(const AudioContexts& contexts) {
    log::debug("context_type_map={}", contexts.to_string());

    auto ccids = ContentControlIdKeeper::GetInstance()->GetAllCcids(contexts);
    if (ccids.empty()) {
      log::warn("No content providers available for context_type_map={}.",
                contexts.to_string());
    }

    std::vector<uint8_t> stream_context_vec(2);
    auto pp = stream_context_vec.data();
    UINT16_TO_STREAM(pp, contexts.value());

    for (auto const& kv_it : broadcasts_) {
      auto& broadcast = kv_it.second;
      if (broadcast->GetState() == BroadcastStateMachine::State::STREAMING) {
        auto announcement = broadcast->GetBroadcastAnnouncement();
        bool broadcast_update = false;

        // Replace context type and CCID list
        for (auto& subgroup : announcement.subgroup_configs) {
          auto subgroup_ltv = LeAudioLtvMap(subgroup.metadata);
          bool subgroup_update = false;

          auto existing_context =
              subgroup_ltv.Find(bluetooth::le_audio::types::
                                    kLeAudioMetadataTypeStreamingAudioContext);
          if (existing_context) {
            if (memcmp(stream_context_vec.data(), existing_context->data(),
                       existing_context->size()) != 0) {
              subgroup_ltv.Add(bluetooth::le_audio::types::
                                   kLeAudioMetadataTypeStreamingAudioContext,
                               stream_context_vec);
              subgroup_update = true;
            }
          } else {
            subgroup_ltv.Add(bluetooth::le_audio::types::
                                 kLeAudioMetadataTypeStreamingAudioContext,
                             stream_context_vec);
            subgroup_update = true;
          }

          auto existing_ccid_list = subgroup_ltv.Find(
              bluetooth::le_audio::types::kLeAudioMetadataTypeCcidList);
          if (existing_ccid_list) {
            if (ccids.empty()) {
              subgroup_ltv.Remove(
                  bluetooth::le_audio::types::kLeAudioMetadataTypeCcidList);
              subgroup_update = true;

            } else if (!std::is_permutation(ccids.begin(), ccids.end(),
                                            existing_ccid_list->begin())) {
              subgroup_ltv.Add(
                  bluetooth::le_audio::types::kLeAudioMetadataTypeCcidList,
                  ccids);
              subgroup_update = true;
            }
          } else if (!ccids.empty()) {
            subgroup_ltv.Add(
                bluetooth::le_audio::types::kLeAudioMetadataTypeCcidList,
                ccids);
            subgroup_update = true;
          }

          if (subgroup_update) {
            subgroup.metadata = subgroup_ltv.Values();
            broadcast_update = true;
          }
        }

        if (broadcast_update) {
          broadcast->UpdateBroadcastAnnouncement(std::move(announcement));
        }
      }
    }
  }

  void UpdateMetadata(
      uint32_t broadcast_id, const std::string& broadcast_name,
      const std::vector<uint8_t>& public_metadata,
      const std::vector<std::vector<uint8_t>>& subgroup_metadata) override {
    std::vector<LeAudioLtvMap> subgroup_ltvs;

    if (broadcasts_.count(broadcast_id) == 0) {
      log::error("No such broadcast_id={}", broadcast_id);
      return;
    }

    log::info("For broadcast_id={}", broadcast_id);

    for (const std::vector<uint8_t>& metadata : subgroup_metadata) {
      /* Prepare the announcement format */
      bool is_metadata_valid;
      auto ltv = LeAudioLtvMap::Parse(metadata.data(), metadata.size(), is_metadata_valid);
      if (!is_metadata_valid) {
        log::error("Invalid metadata provided.");
        return;
      }

      auto context_type = AudioContexts(LeAudioContextType::MEDIA);

      /* Adds multiple contexts and CCIDs regardless of the incoming audio
       * context. Android has only two CCIDs, one for Media and one for
       * Conversational context. Even though we are not broadcasting
       * Conversational streams, some PTS test cases wants multiple CCIDs.
       */
      if (stack_config_get_interface()
              ->get_pts_force_le_audio_multiple_contexts_metadata()) {
        context_type =
            LeAudioContextType::MEDIA | LeAudioContextType::CONVERSATIONAL;
        auto stream_context_vec =
            ltv.Find(bluetooth::le_audio::types::
                         kLeAudioMetadataTypeStreamingAudioContext);
        if (stream_context_vec) {
          auto pp = stream_context_vec.value().data();
          if (stream_context_vec.value().size() < 2) {
            log::error("stream_context_vec.value() size < 2");
            return;
          }
          UINT16_TO_STREAM(pp, context_type.value());
        }
      }

      auto stream_context_vec =
          ltv.Find(bluetooth::le_audio::types::
                       kLeAudioMetadataTypeStreamingAudioContext);
      if (stream_context_vec) {
        auto pp = stream_context_vec.value().data();
        if (stream_context_vec.value().size() < 2) {
          log::error("stream_context_vec.value() size < 2");
          return;
        }
        STREAM_TO_UINT16(context_type.value_ref(), pp);
      }

      // Append the CCID list
      auto ccid_vec =
          ContentControlIdKeeper::GetInstance()->GetAllCcids(context_type);
      if (!ccid_vec.empty()) {
        ltv.Add(bluetooth::le_audio::types::kLeAudioMetadataTypeCcidList,
                ccid_vec);
      }

      // Push to subgroup ltvs
      subgroup_ltvs.push_back(ltv);
    }

    if (broadcasts_[broadcast_id]->IsPublicBroadcast()) {
      // Only update broadcast name and public metadata if current broadcast is
      // public Otherwise ignore those fields
      bool is_public_metadata_valid;
      LeAudioLtvMap public_ltv =
          LeAudioLtvMap::Parse(public_metadata.data(), public_metadata.size(),
                               is_public_metadata_valid);
      if (!is_public_metadata_valid) {
        log::error("Invalid public metadata provided.");
        return;
      }
      PublicBroadcastAnnouncementData pb_announcement =
          preparePublicAnnouncement(broadcasts_[broadcast_id]
                                        ->GetPublicBroadcastAnnouncement()
                                        .features,
                                    public_ltv);

      broadcasts_[broadcast_id]->UpdatePublicBroadcastAnnouncement(
          broadcast_id, broadcast_name, pb_announcement);
    }

    auto& subgroup_configs = broadcasts_[broadcast_id]->GetCodecConfig();
    BasicAudioAnnouncementData announcement =
        prepareBasicAnnouncement(subgroup_configs, subgroup_ltvs);

    broadcasts_[broadcast_id]->UpdateBroadcastAnnouncement(
        std::move(announcement));
  }

  /* Choose the dominating audio context when multiple contexts are mixed */
  LeAudioContextType ChooseConfigurationContextType(
      AudioContexts audio_contexts) {
    log::debug("Got contexts={}", bluetooth::common::ToString(audio_contexts));

    /* Prioritize the most common use cases. */
    if (audio_contexts.any()) {
      LeAudioContextType context_priority_list[] = {
          LeAudioContextType::LIVE,          LeAudioContextType::GAME,
          LeAudioContextType::MEDIA,         LeAudioContextType::EMERGENCYALARM,
          LeAudioContextType::ALERTS,        LeAudioContextType::INSTRUCTIONAL,
          LeAudioContextType::NOTIFICATIONS, LeAudioContextType::SOUNDEFFECTS,
      };
      for (auto ct : context_priority_list) {
        if (audio_contexts.test(ct)) {
          log::debug("Selecting configuration context type: {}", ToString(ct));
          return ct;
        }
      }
    }

    auto fallback_config = LeAudioContextType::MEDIA;
    log::debug("Selecting configuration context type: {}",
               ToString(fallback_config));
    return fallback_config;
  }

  void CreateAudioBroadcast(
      bool is_public, const std::string& broadcast_name,
      const std::optional<bluetooth::le_audio::BroadcastCode>& broadcast_code,
      const std::vector<uint8_t>& public_metadata,
      const std::vector<uint8_t>& subgroup_quality,
      const std::vector<std::vector<uint8_t>>& subgroup_metadata) override {
    uint8_t public_features = 0;
    LeAudioLtvMap public_ltv;
    std::vector<LeAudioLtvMap> subgroup_ltvs;

    if (queued_create_broadcast_request_) {
      log::error("Not processed yet queued broadcast");
      callbacks_->OnBroadcastCreated(bluetooth::le_audio::kBroadcastIdInvalid,
                                     false);
      return;
    }

    if (is_public) {
      // Prepare public broadcast announcement format
      bool is_metadata_valid;
      public_ltv = LeAudioLtvMap::Parse(
          public_metadata.data(), public_metadata.size(), is_metadata_valid);
      if (!is_metadata_valid) {
        log::error("Invalid metadata provided.");
        callbacks_->OnBroadcastCreated(bluetooth::le_audio::kBroadcastIdInvalid,
                                       false);
        return;
      }
      // Prepare public features byte
      // bit 0 Encryption broadcast stream encrypted or not
      // bit 1 Standard quality audio configuration present or not
      // bit 2 High quality audio configuration present or not
      // bit 3-7 RFU
      public_features = static_cast<uint8_t>(broadcast_code ? 1 : 0);
    }

    auto broadcast_id = available_broadcast_ids_.back();
    available_broadcast_ids_.pop_back();
    if (available_broadcast_ids_.size() == 0) GenerateBroadcastIds();

    auto context_type = AudioContexts(LeAudioContextType::MEDIA);

    /* Adds multiple contexts and CCIDs regardless of the incoming audio
     * context. Android has only two CCIDs, one for Media and one for
     * Conversational context. Even though we are not broadcasting
     * Conversational streams, some PTS test cases wants multiple CCIDs.
     */
    if (stack_config_get_interface()
            ->get_pts_force_le_audio_multiple_contexts_metadata()) {
      context_type =
          LeAudioContextType::MEDIA | LeAudioContextType::CONVERSATIONAL;
    }

    for (const uint8_t quality : subgroup_quality) {
      if (quality == bluetooth::le_audio::QUALITY_STANDARD) {
        public_features |= bluetooth::le_audio::kLeAudioQualityStandard;
      } else if (quality == bluetooth::le_audio::QUALITY_HIGH) {
        public_features |= bluetooth::le_audio::kLeAudioQualityHigh;
      }
    }

    for (const std::vector<uint8_t>& metadata : subgroup_metadata) {
      /* Prepare the announcement format */
      bool is_metadata_valid;
      auto ltv = LeAudioLtvMap::Parse(metadata.data(), metadata.size(), is_metadata_valid);
      if (!is_metadata_valid) {
        log::error("Invalid metadata provided.");
        callbacks_->OnBroadcastCreated(bluetooth::le_audio::kBroadcastIdInvalid,
                                       false);
        return;
      }

      if (stack_config_get_interface()
              ->get_pts_force_le_audio_multiple_contexts_metadata()) {
        auto stream_context_vec =
            ltv.Find(bluetooth::le_audio::types::
                         kLeAudioMetadataTypeStreamingAudioContext);
        if (stream_context_vec) {
          if (stream_context_vec.value().size() < 2) {
            log::error("kLeAudioMetadataTypeStreamingAudioContext size < 2");
            callbacks_->OnBroadcastCreated(
                bluetooth::le_audio::kBroadcastIdInvalid, false);
            return;
          }
          auto pp = stream_context_vec.value().data();
          UINT16_TO_STREAM(pp, context_type.value());
        }
      }

      auto stream_context_vec =
          ltv.Find(bluetooth::le_audio::types::
                       kLeAudioMetadataTypeStreamingAudioContext);
      if (stream_context_vec) {
        if (stream_context_vec.value().size() < 2) {
          log::error("kLeAudioMetadataTypeStreamingAudioContext size < 2");
          callbacks_->OnBroadcastCreated(
              bluetooth::le_audio::kBroadcastIdInvalid, false);
          return;
        }

        auto pp = stream_context_vec.value().data();
        STREAM_TO_UINT16(context_type.value_ref(), pp);
      }

      // Append the CCID list
      auto ccid_vec =
          ContentControlIdKeeper::GetInstance()->GetAllCcids(context_type);
      if (!ccid_vec.empty()) {
        ltv.Add(bluetooth::le_audio::types::kLeAudioMetadataTypeCcidList,
                ccid_vec);
      }

      // Push to subgroup ltvs
      subgroup_ltvs.push_back(ltv);
    }

    // Prepare the configuration requirements for each subgroup.
    // Note: For now, each subgroup contains exactly the same content, but
    // differs in codec configuration.
    CodecManager::BroadcastConfigurationRequirements requirements;
    for (auto& idx : subgroup_quality) {
      requirements.subgroup_quality.push_back(
          {ChooseConfigurationContextType(context_type), idx});
    }

    if (!le_audio_source_hal_client_) {
      le_audio_source_hal_client_ =
          LeAudioSourceAudioHalClient::AcquireBroadcast();
      if (!le_audio_source_hal_client_) {
        log::error("Could not acquire le audio");
        return;
      }
      auto result =
          CodecManager::GetInstance()->UpdateActiveBroadcastAudioHalClient(
              le_audio_source_hal_client_.get(), true);
      log::assert_that(result, "Could not update session in codec manager");
    }

    auto config = CodecManager::GetInstance()->GetBroadcastConfig(requirements);
    if (!config) {
      log::error("No valid broadcast offload config");
      callbacks_->OnBroadcastCreated(bluetooth::le_audio::kBroadcastIdInvalid,
                                     false);
      return;
    }

    if (public_features & bluetooth::le_audio::kLeAudioQualityHigh &&
        config->GetSamplingFrequencyHzMax() < 48000) {
      log::warn(
          "Preferred quality isn't supported. Fallback to standard audio "
          "quality");
      public_features &= (0xFFFF & ~bluetooth::le_audio::kLeAudioQualityHigh);
      public_features |= bluetooth::le_audio::kLeAudioQualityStandard;
    }

    BroadcastStateMachineConfig msg = {
        .is_public = is_public,
        .broadcast_id = broadcast_id,
        .broadcast_name = broadcast_name,
        .streaming_phy = GetStreamingPhy(),
        .config = *config,
        .announcement =
            prepareBasicAnnouncement(config->subgroups, subgroup_ltvs),
        .broadcast_code = std::move(broadcast_code)};
    if (is_public) {
      msg.public_announcement =
          preparePublicAnnouncement(public_features, public_ltv);
    }

    // If there is ongoing ISO traffic, it might be a unicast stream
    if (is_iso_running_) {
      log::info("Iso is still active. Queueing broadcast creation for later.");
      if (queued_create_broadcast_request_) {
        log::warn(
            "Already queued. Updating queued broadcast creation with the new "
            "configuration.");
      }
      queued_create_broadcast_request_ = std::move(msg);
      return;
    }

    InstantiateBroadcast(std::move(msg));
  }

  void InstantiateBroadcast(BroadcastStateMachineConfig msg) {
    log::info("CreateAudioBroadcast");

    /* Put the new broadcast on the initialization queue, notify the error and
     * drop the pending broadcast data if init fails.
     */
    pending_broadcasts_.push_back(
        BroadcastStateMachine::CreateInstance(std::move(msg)));
    if (!pending_broadcasts_.back()->Initialize()) {
      pending_broadcasts_.pop_back();
      callbacks_->OnBroadcastCreated(bluetooth::le_audio::kBroadcastIdInvalid,
                                     false);
    }
  }

  void SuspendAudioBroadcast(uint32_t broadcast_id) override {
    log::info("broadcast_id={}", broadcast_id);

    if (broadcasts_.count(broadcast_id) != 0) {
      log::info("Stopping AudioHalClient");
      if (le_audio_source_hal_client_) le_audio_source_hal_client_->Stop();
      broadcasts_[broadcast_id]->SetMuted(true);
      broadcasts_[broadcast_id]->ProcessMessage(
          BroadcastStateMachine::Message::SUSPEND, nullptr);
    } else {
      log::error("No such broadcast_id={}", broadcast_id);
    }
  }

  static bool IsAnyoneStreaming() {
    if (!instance) return false;

    auto const& iter =
        std::find_if(instance->broadcasts_.cbegin(),
                     instance->broadcasts_.cend(), [](auto const& sm) {
                       return sm.second->GetState() ==
                              BroadcastStateMachine::State::STREAMING;
                     });
    return (iter != instance->broadcasts_.cend());
  }

  void StartAudioBroadcast(uint32_t broadcast_id) override {
    log::info("Starting broadcast_id={}", broadcast_id);

    if (queued_start_broadcast_request_) {
      log::error("Not processed yet start broadcast request");
      return;
    }

    if (is_iso_running_) {
      queued_start_broadcast_request_ = broadcast_id;
      return;
    }

    if (IsAnyoneStreaming()) {
      log::error("Stop the other broadcast first!");
      return;
    }

    if (broadcasts_.count(broadcast_id) != 0) {
      if (!le_audio_source_hal_client_) {
        le_audio_source_hal_client_ =
            LeAudioSourceAudioHalClient::AcquireBroadcast();
        if (!le_audio_source_hal_client_) {
          log::error("Could not acquire le audio");
          return;
        }

        auto result =
            CodecManager::GetInstance()->UpdateActiveBroadcastAudioHalClient(
                le_audio_source_hal_client_.get(), true);
        log::assert_that(result, "Could not update session in codec manager");
      }

      broadcasts_[broadcast_id]->ProcessMessage(
          BroadcastStateMachine::Message::START, nullptr);
      bluetooth::le_audio::MetricsCollector::Get()->OnBroadcastStateChanged(
          true);
    } else {
      log::error("No such broadcast_id={}", broadcast_id);
    }
  }

  void StopAudioBroadcast(uint32_t broadcast_id) override {
    if (broadcasts_.count(broadcast_id) == 0) {
      log::error("no such broadcast_id={}", broadcast_id);
      return;
    }

    log::info("Stopping AudioHalClient, broadcast_id={}", broadcast_id);

    if (le_audio_source_hal_client_) le_audio_source_hal_client_->Stop();
    broadcasts_[broadcast_id]->SetMuted(true);
    broadcasts_[broadcast_id]->ProcessMessage(
        BroadcastStateMachine::Message::STOP, nullptr);
    bluetooth::le_audio::MetricsCollector::Get()->OnBroadcastStateChanged(
        false);
  }

  void DestroyAudioBroadcast(uint32_t broadcast_id) override {
    log::info("Destroying broadcast_id={}", broadcast_id);
    broadcasts_.erase(broadcast_id);

    if (broadcasts_.empty() && le_audio_source_hal_client_) {
      auto result =
          CodecManager::GetInstance()->UpdateActiveBroadcastAudioHalClient(
              le_audio_source_hal_client_.get(), false);
      log::assert_that(result, "Could not update session in codec manager");
      le_audio_source_hal_client_.reset();
    }
  }

  std::optional<bluetooth::le_audio::BroadcastMetadata> GetBroadcastMetadataOpt(
      bluetooth::le_audio::BroadcastId broadcast_id) {
    bluetooth::le_audio::BroadcastMetadata metadata;
    for (auto const& kv_it : broadcasts_) {
      if (kv_it.second->GetBroadcastId() == broadcast_id) {
        metadata.is_public = kv_it.second->IsPublicBroadcast();
        metadata.broadcast_id = kv_it.second->GetBroadcastId();
        metadata.broadcast_name = kv_it.second->GetBroadcastName();
        metadata.adv_sid = kv_it.second->GetAdvertisingSid();
        metadata.pa_interval = kv_it.second->GetPaInterval();
        metadata.addr = kv_it.second->GetOwnAddress();
        metadata.addr_type = kv_it.second->GetOwnAddressType();
        metadata.broadcast_code = kv_it.second->GetBroadcastCode();
        metadata.basic_audio_announcement =
            kv_it.second->GetBroadcastAnnouncement();
        metadata.public_announcement =
            kv_it.second->GetPublicBroadcastAnnouncement();
        return metadata;
      }
    }
    return std::nullopt;
  }

  void GetBroadcastMetadata(uint32_t broadcast_id) override {
    if (broadcasts_.count(broadcast_id) == 0) {
      log::error("No such broadcast_id={}", broadcast_id);
      return;
    }

    auto meta = GetBroadcastMetadataOpt(broadcast_id);
    if (!meta) {
      log::error("No metadata for broadcast_id={}", broadcast_id);
      return;
    }
    callbacks_->OnBroadcastMetadataChanged(broadcast_id,
                                           std::move(meta.value()));
  }

  void GetAllBroadcastStates(void) override {
    for (auto const& kv_it : broadcasts_) {
      callbacks_->OnBroadcastStateChanged(
          kv_it.second->GetBroadcastId(),
          static_cast<bluetooth::le_audio::BroadcastState>(
              kv_it.second->GetState()));
    }
  }

  void IsValidBroadcast(
      uint32_t broadcast_id, uint8_t addr_type, RawAddress addr,
      base::Callback<void(uint8_t /* broadcast_id */, uint8_t /* addr_type */,
                          RawAddress /* addr */, bool /* is_local */)>
          cb) override {
    if (broadcasts_.count(broadcast_id) == 0) {
      log::error("No such broadcast_id={}", broadcast_id);
      std::move(cb).Run(broadcast_id, addr_type, addr, false);
      return;
    }

    broadcasts_[broadcast_id]->RequestOwnAddress(base::Bind(
        [](uint32_t broadcast_id, uint8_t req_address_type,
           RawAddress req_address,
           base::Callback<void(uint8_t /* broadcast_id */,
                               uint8_t /* addr_type */, RawAddress /* addr */,
                               bool /* is_local */)>
               cb,
           uint8_t rcv_address_type, RawAddress rcv_address) {
          bool is_local = (req_address_type == rcv_address_type) &&
                          (req_address == rcv_address);
          std::move(cb).Run(broadcast_id, req_address_type, req_address,
                            is_local);
        },
        broadcast_id, addr_type, addr, std::move(cb)));
  }

  void SetStreamingPhy(uint8_t phy) override { current_phy_ = phy; }

  uint8_t GetStreamingPhy(void) const override { return current_phy_; }

  BroadcastId BroadcastIdFromBigHandle(uint8_t big_handle) const {
    auto pair_it =
        std::find_if(broadcasts_.begin(), broadcasts_.end(),
                     [big_handle](auto const& entry) {
                       return entry.second->GetAdvertisingSid() == big_handle;
                     });
    if (pair_it != broadcasts_.end()) {
      return pair_it->second->GetBroadcastId();
    }
    return bluetooth::le_audio::kBroadcastIdInvalid;
  }

  void OnSetupIsoDataPath(uint8_t status, uint16_t conn_handle,
                          uint8_t big_handle) override {
    auto broadcast_id = BroadcastIdFromBigHandle(big_handle);
    log::assert_that(broadcasts_.count(broadcast_id) != 0,
                     "assert failed: broadcasts_.count(broadcast_id) != 0");
    broadcasts_[broadcast_id]->OnSetupIsoDataPath(status, conn_handle);
  }

  void OnRemoveIsoDataPath(uint8_t status, uint16_t conn_handle,
                           uint8_t big_handle) override {
    auto broadcast_id = BroadcastIdFromBigHandle(big_handle);
    log::assert_that(broadcasts_.count(broadcast_id) != 0,
                     "assert failed: broadcasts_.count(broadcast_id) != 0");
    broadcasts_[broadcast_id]->OnRemoveIsoDataPath(status, conn_handle);
  }

  void OnBigEvent(uint8_t event, void* data) override {
    switch (event) {
      case bluetooth::hci::iso_manager::kIsoEventBigOnCreateCmpl: {
        auto* evt = static_cast<big_create_cmpl_evt*>(data);
        auto broadcast_id = BroadcastIdFromBigHandle(evt->big_id);
        log::assert_that(broadcasts_.count(broadcast_id) != 0,
                         "assert failed: broadcasts_.count(broadcast_id) != 0");
        broadcasts_[broadcast_id]->HandleHciEvent(HCI_BLE_CREATE_BIG_CPL_EVT,
                                                  evt);

      } break;
      case bluetooth::hci::iso_manager::kIsoEventBigOnTerminateCmpl: {
        auto* evt = static_cast<big_terminate_cmpl_evt*>(data);
        auto broadcast_id = BroadcastIdFromBigHandle(evt->big_id);
        log::assert_that(broadcasts_.count(broadcast_id) != 0,
                         "assert failed: broadcasts_.count(broadcast_id) != 0");
        broadcasts_[broadcast_id]->HandleHciEvent(HCI_BLE_TERM_BIG_CPL_EVT,
                                                  evt);
        auto result =
            CodecManager::GetInstance()->UpdateActiveBroadcastAudioHalClient(
                le_audio_source_hal_client_.get(), false);
        log::assert_that(result, "Could not update session in codec manager");
        le_audio_source_hal_client_.reset();
      } break;
      default:
        log::error("Invalid event={}", event);
    }
  }

  void IsoTrafficEventCb(bool is_active) {
    is_iso_running_ = is_active;
    log::info("is_iso_running: {}", is_iso_running_);
    if (!is_iso_running_) {
      if (queued_start_broadcast_request_) {
        auto broadcast_id = *queued_start_broadcast_request_;
        queued_start_broadcast_request_ = std::nullopt;

        log::info("Start queued broadcast.");
        StartAudioBroadcast(broadcast_id);
      }
      if (queued_create_broadcast_request_) {
        auto broadcast_msg = std::move(*queued_create_broadcast_request_);
        queued_create_broadcast_request_ = std::nullopt;

        log::info("Create queued broadcast.");
        InstantiateBroadcast(std::move(broadcast_msg));
      }
    }
  }

  void Dump(int fd) {
    std::stringstream stream;

    stream << "    Number of broadcasts: " << broadcasts_.size() << "\n";
    for (auto& broadcast_pair : broadcasts_) {
      auto& broadcast = broadcast_pair.second;
      if (broadcast) stream << *broadcast;
    }

    dprintf(fd, "%s", stream.str().c_str());
  }

 private:
  static class BroadcastStateMachineCallbacks
      : public IBroadcastStateMachineCallbacks {
    void OnStateMachineCreateStatus(uint32_t broadcast_id,
                                    bool initialized) override {
      auto pending_broadcast = std::find_if(
          instance->pending_broadcasts_.begin(),
          instance->pending_broadcasts_.end(), [broadcast_id](auto& sm) {
            return (sm->GetBroadcastId() == broadcast_id);
          });
      log::assert_that(pending_broadcast != instance->pending_broadcasts_.end(),
                       "assert failed: pending_broadcast != "
                       "instance->pending_broadcasts_.end()");
      log::assert_that(
          instance->broadcasts_.count(broadcast_id) == 0,
          "assert failed: instance->broadcasts_.count(broadcast_id) == 0");

      if (initialized) {
        const uint32_t broadcast_id = (*pending_broadcast)->GetBroadcastId();
        log::info("broadcast_id={} state={}", broadcast_id,
                  ToString((*pending_broadcast)->GetState()));

        instance->broadcasts_[broadcast_id] = std::move(*pending_broadcast);
      } else {
        log::error("Failed creating broadcast!");
      }
      instance->pending_broadcasts_.erase(pending_broadcast);
      instance->callbacks_->OnBroadcastCreated(broadcast_id, initialized);
    }

    void OnStateMachineDestroyed(uint32_t broadcast_id) override {
      /* This is a special case when state machine destructor calls this
       * callback. It may happen during the Cleanup() call when all state
       * machines are erased and instance can already be set to null to avoid
       * unnecessary calls.
       */
      if (instance) instance->callbacks_->OnBroadcastDestroyed(broadcast_id);
    }

    static int getStreamerCount() {
      return std::count_if(instance->broadcasts_.begin(),
                           instance->broadcasts_.end(), [](auto const& sm) {
                             log::verbose("broadcast_id={}, state={}",
                                          sm.second->GetBroadcastId(),
                                          ToString(sm.second->GetState()));
                             return sm.second->GetState() ==
                                    BroadcastStateMachine::State::STREAMING;
                           });
    }

    void OnStateMachineEvent(uint32_t broadcast_id,
                             BroadcastStateMachine::State state,
                             const void* data) override {
      log::info("broadcast_id={} state={}", broadcast_id, ToString(state));

      switch (state) {
        case BroadcastStateMachine::State::STOPPED:
          /* Pass through */
        case BroadcastStateMachine::State::CONFIGURING:
          /* Pass through */
        case BroadcastStateMachine::State::CONFIGURED:
          /* Pass through */
        case BroadcastStateMachine::State::STOPPING:
          /* Nothing to do here? */
          break;
        case BroadcastStateMachine::State::STREAMING:
          if (getStreamerCount() == 1) {
            log::info("Starting AudioHalClient");

            if (instance->broadcasts_.count(broadcast_id) != 0) {
              const auto& broadcast = instance->broadcasts_.at(broadcast_id);
              const auto& broadcast_config = broadcast->GetBroadcastConfig();

              // Reconfigure encoder instances for the new stream requirements
              audio_receiver_.CheckAndReconfigureEncoders(broadcast_config);

              broadcast->SetMuted(false);
              auto is_started = instance->le_audio_source_hal_client_->Start(
                  broadcast_config.GetAudioHalClientConfig(), &audio_receiver_);
              if (!is_started) {
                /* Audio Source setup failed - stop the broadcast */
                instance->StopAudioBroadcast(broadcast_id);
                return;
              }

              instance->audio_data_path_state_ = AudioDataPathState::ACTIVE;
            }
          }
          break;
      };

      instance->callbacks_->OnBroadcastStateChanged(
          broadcast_id,
          static_cast<bluetooth::le_audio::BroadcastState>(state));
    }

    void OnOwnAddressResponse(uint32_t broadcast_id, uint8_t addr_type,
                              RawAddress addr) override {
      /* Not used currently */
    }

    void OnBigCreated(const std::vector<uint16_t>& conn_handle) {
      CodecManager::GetInstance()->UpdateBroadcastConnHandle(
          conn_handle,
          std::bind(
              &LeAudioSourceAudioHalClient::UpdateBroadcastAudioConfigToHal,
              instance->le_audio_source_hal_client_.get(),
              std::placeholders::_1));
    }
  } state_machine_callbacks_;

  static class BroadcastAdvertisingCallbacks : public AdvertisingCallbacks {
    void OnAdvertisingSetStarted(int reg_id, uint8_t advertiser_id,
                                 int8_t tx_power, uint8_t status) {
      if (!instance) return;

      if (reg_id == BroadcastStateMachine::kLeAudioBroadcastRegId &&
          !instance->pending_broadcasts_.empty()) {
        instance->pending_broadcasts_.back()->OnCreateAnnouncement(
            advertiser_id, tx_power, status);
      } else {
        log::warn(
            "Ignored OnAdvertisingSetStarted callback reg_id:{} "
            "advertiser_id:{}",
            reg_id, advertiser_id);
      }
    }

    void OnAdvertisingEnabled(uint8_t advertiser_id, bool enable,
                              uint8_t status) {
      if (!instance) return;

      auto const& iter = std::find_if(
          instance->broadcasts_.cbegin(), instance->broadcasts_.cend(),
          [advertiser_id](auto const& sm) {
            return sm.second->GetAdvertisingSid() == advertiser_id;
          });
      if (iter != instance->broadcasts_.cend()) {
        iter->second->OnEnableAnnouncement(enable, status);
      } else {
        log::warn("Ignored OnAdvertisingEnabled callback advertiser_id:{}",
                  advertiser_id);
      }
    }

    void OnAdvertisingDataSet(uint8_t advertiser_id, uint8_t status) {
      log::warn(
          "Not being used, ignored OnAdvertisingDataSet callback "
          "advertiser_id:{}",
          advertiser_id);
    }

    void OnScanResponseDataSet(uint8_t advertiser_id, uint8_t status) {
      log::warn(
          "Not being used, ignored OnScanResponseDataSet callback "
          "advertiser_id:{}",
          advertiser_id);
    }

    void OnAdvertisingParametersUpdated(uint8_t advertiser_id, int8_t tx_power,
                                        uint8_t status) {
      log::warn(
          "Not being used, ignored OnAdvertisingParametersUpdated callback "
          "advertiser_id:{}",
          advertiser_id);
    }

    void OnPeriodicAdvertisingParametersUpdated(uint8_t advertiser_id,
                                                uint8_t status) {
      log::warn(
          "Not being used, ignored OnPeriodicAdvertisingParametersUpdated "
          "callback advertiser_id:{}",
          advertiser_id);
    }

    void OnPeriodicAdvertisingDataSet(uint8_t advertiser_id, uint8_t status) {
      log::warn(
          "Not being used, ignored OnPeriodicAdvertisingDataSet callback "
          "advertiser_id:{}",
          advertiser_id);
    }

    void OnPeriodicAdvertisingEnabled(uint8_t advertiser_id, bool enable,
                                      uint8_t status) {
      log::warn(
          "Not being used, ignored OnPeriodicAdvertisingEnabled callback "
          "advertiser_id:{}",
          advertiser_id);
    }

    void OnOwnAddressRead(uint8_t advertiser_id, uint8_t address_type,
                          RawAddress address) {
      log::warn(
          "Not being used, ignored OnOwnAddressRead callback advertiser_id:{}",
          advertiser_id);
    }
  } state_machine_adv_callbacks_;

  static class LeAudioSourceCallbacksImpl
      : public LeAudioSourceAudioHalClient::Callbacks {
   public:
    LeAudioSourceCallbacksImpl() = default;
    void CheckAndReconfigureEncoders(
        const BroadcastConfiguration& broadcast_config) {
      /* TODO: Move software codec instance management to the Codec Manager */
      if (CodecManager::GetInstance()->GetCodecLocation() ==
          CodecLocation::ADSP) {
        return;
      }

      auto codec_config = broadcast_config.GetAudioHalClientConfig();

      /* Note: Currently we support only a single subgroup software encoding.
       * In future consider mirroring the same data in a different quality
       * subgroups.
       */
      auto const& subgroup_config = broadcast_config.subgroups.at(0);

      auto const& codec_id = subgroup_config.GetLeAudioCodecId();
      /* TODO: We should act smart and reuse current configurations */
      sw_enc_.clear();
      while (sw_enc_.size() != subgroup_config.GetNumChannelsTotal()) {
        auto codec =
            bluetooth::le_audio::CodecInterface::CreateInstance(codec_id);

        auto codec_status = codec->InitEncoder(codec_config, codec_config);
        if (codec_status !=
            bluetooth::le_audio::CodecInterface::Status::STATUS_OK) {
          log::error("Channel {} codec setup failed with err: {}",
                     (uint32_t)sw_enc_.size(), codec_status);
          return;
        }

        sw_enc_.emplace_back(std::move(codec));
      }

      broadcast_config_ = broadcast_config;
    }

    static void sendBroadcastData(
        const std::unique_ptr<BroadcastStateMachine>& broadcast,
        std::vector<std::unique_ptr<bluetooth::le_audio::CodecInterface>>&
            encoders) {
      auto const& config = broadcast->GetBigConfig();
      if (config == std::nullopt) {
        log::error(
            "Broadcast broadcast_id={} has no valid BIS configurations in "
            "state={}",
            broadcast->GetBroadcastId(), ToString(broadcast->GetState()));
        return;
      }

      if (config->connection_handles.size() < encoders.size()) {
        log::error("Not enough BIS'es to broadcast all channels!");
        return;
      }

      for (uint8_t chan = 0; chan < encoders.size(); ++chan) {
        IsoManager::GetInstance()->SendIsoData(
            config->connection_handles[chan],
            (const uint8_t*)encoders[chan]->GetDecodedSamples().data(),
            encoders[chan]->GetDecodedSamples().size() * 2);
      }
    }

    virtual void OnAudioDataReady(const std::vector<uint8_t>& data) override {
      if (!instance) return;

      log::verbose("Received {} bytes.", data.size());

      if (!broadcast_config_.has_value() ||
          (broadcast_config_->subgroups.size() == 0)) {
        log::error("Codec was not configured properly");
        return;
      }

      /* Note: Currently we support only a single subgroup.
       * In future consider mirroring the same data in a different quality
       * subgroups.
       */
      auto const& subgroup_config = broadcast_config_->subgroups.at(0);

      /* Constants for the channel data configuration */
      const auto num_bis = subgroup_config.GetNumBis();
      const auto bytes_per_sample = (subgroup_config.GetBitsPerSample() / 8);

      /* Prepare encoded data for all channels */
      for (uint8_t bis_idx = 0; bis_idx < num_bis; ++bis_idx) {
        auto initial_channel_offset = bis_idx * bytes_per_sample;
        sw_enc_[bis_idx]->Encode(
            data.data() + initial_channel_offset, num_bis,
            subgroup_config.GetBisOctetsPerCodecFrame(bis_idx));
      }

      /* Currently there is no way to broadcast multiple distinct streams.
       * We just receive all system sounds mixed into a one stream and each
       * broadcast gets the same data.
       */
      for (auto& broadcast_pair : instance->broadcasts_) {
        auto& broadcast = broadcast_pair.second;
        if ((broadcast->GetState() ==
             BroadcastStateMachine::State::STREAMING) &&
            !broadcast->IsMuted())
          sendBroadcastData(broadcast, sw_enc_);
      }
      log::verbose("All data sent.");
    }

    virtual void OnAudioSuspend(void) override {
      log::info("");
      /* TODO: Should we suspend all broadcasts - remove BIGs? */
      if (instance)
        instance->audio_data_path_state_ = AudioDataPathState::SUSPENDED;
    }

    virtual void OnAudioResume(void) override {
      log::info("");
      if (!instance) return;

      /* TODO: Should we resume all broadcasts - recreate BIGs? */
      instance->audio_data_path_state_ = AudioDataPathState::ACTIVE;

      if (!IsAnyoneStreaming()) {
        instance->le_audio_source_hal_client_->CancelStreamingRequest();
        return;
      }

      instance->le_audio_source_hal_client_->ConfirmStreamingRequest();
    }

    virtual void OnAudioMetadataUpdate(
        const std::vector<struct playback_track_metadata_v7> source_metadata,
        DsaMode dsa_mode) override {
      log::info("");
      if (!instance) return;

      /* TODO: Should we take supported contexts from ASCS? */
      auto contexts = GetAudioContextsFromSourceMetadata(source_metadata);
      if (contexts.any()) {
        /* NOTICE: We probably don't want to change the stream configuration
         * on each metadata change, so just update the context type metadata.
         * Since we are not able to identify individual track streams and
         * they are all mixed inside a single data stream, we will update
         * the metadata of all BIS subgroups with the same combined context.
         */
        instance->UpdateStreamingContextTypeOnAllSubgroups(contexts);
      }
    }

   private:
    std::optional<BroadcastConfiguration> broadcast_config_;
    std::vector<std::unique_ptr<bluetooth::le_audio::CodecInterface>> sw_enc_;
  } audio_receiver_;

  bluetooth::le_audio::LeAudioBroadcasterCallbacks* callbacks_;
  std::map<uint32_t, std::unique_ptr<BroadcastStateMachine>> broadcasts_;
  std::vector<std::unique_ptr<BroadcastStateMachine>> pending_broadcasts_;
  std::optional<BroadcastStateMachineConfig> queued_create_broadcast_request_;
  std::optional<uint32_t> queued_start_broadcast_request_;

  /* Some BIG params are set globally */
  uint8_t current_phy_;
  AudioDataPathState audio_data_path_state_;
  std::unique_ptr<LeAudioSourceAudioHalClient> le_audio_source_hal_client_;
  std::vector<BroadcastId> available_broadcast_ids_;

  // Flag to track iso state
  bool is_iso_running_ = false;
};

/* Static members definitions */
LeAudioBroadcasterImpl::BroadcastStateMachineCallbacks
    LeAudioBroadcasterImpl::state_machine_callbacks_;
LeAudioBroadcasterImpl::LeAudioSourceCallbacksImpl
    LeAudioBroadcasterImpl::audio_receiver_;
LeAudioBroadcasterImpl::BroadcastAdvertisingCallbacks
    LeAudioBroadcasterImpl::state_machine_adv_callbacks_;
} /* namespace */

void LeAudioBroadcaster::Initialize(
    bluetooth::le_audio::LeAudioBroadcasterCallbacks* callbacks,
    base::Callback<bool()> audio_hal_verifier) {
  std::scoped_lock<std::mutex> lock(instance_mutex);
  log::info("");
  if (instance) {
    log::error("Already initialized");
    return;
  }

  if (!bluetooth::shim::GetController()->SupportsBleIsochronousBroadcaster() &&
      !osi_property_get_bool("persist.bluetooth.fake_iso_support", false)) {
    log::warn("Isochronous Broadcast not supported by the controller!");
    return;
  }

  if (!std::move(audio_hal_verifier).Run()) {
    log::fatal("HAL requirements not met. Init aborted.");
  }

  IsoManager::GetInstance()->Start();

  instance = new LeAudioBroadcasterImpl(callbacks);
  /* Register HCI event handlers */
  IsoManager::GetInstance()->RegisterBigCallbacks(instance);
  /* Register for active traffic */
  IsoManager::GetInstance()->RegisterOnIsoTrafficActiveCallback(
      [](bool is_active) {
        if (instance) instance->IsoTrafficEventCb(is_active);
      });
}

bool LeAudioBroadcaster::IsLeAudioBroadcasterRunning() { return instance; }

LeAudioBroadcaster* LeAudioBroadcaster::Get(void) {
  log::info("");
  log::assert_that(instance != nullptr, "assert failed: instance != nullptr");
  return instance;
}

void LeAudioBroadcaster::Stop(void) {
  log::info("");

  if (instance) {
    instance->Stop();
  }
}

void LeAudioBroadcaster::Cleanup(void) {
  std::scoped_lock<std::mutex> lock(instance_mutex);
  log::info("");

  if (instance == nullptr) return;

  LeAudioBroadcasterImpl* ptr = instance;
  instance = nullptr;

  ptr->CleanUp();
  delete ptr;
}

void LeAudioBroadcaster::DebugDump(int fd) {
  std::scoped_lock<std::mutex> lock(instance_mutex);
  dprintf(fd, "Le Audio Broadcaster:\n");
  if (instance) instance->Dump(fd);
  dprintf(fd, "\n");
}