// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "codec_factory_app.h"

#include <dirent.h>
#include <fuchsia/hardware/mediacodec/cpp/fidl.h>
#include <fuchsia/media/cpp/fidl.h>
#include <fuchsia/mediacodec/cpp/fidl.h>
#include <fuchsia/metrics/cpp/fidl.h>
#include <fuchsia/sysinfo/cpp/fidl.h>
#include <lib/fdio/directory.h>
#include <lib/fidl/cpp/interface_request.h>
#include <lib/fidl/cpp/string.h>
#include <lib/fidl/cpp/vector.h>
#include <lib/sys/cpp/component_context.h>
#include <lib/syslog/cpp/macros.h>
#include <lib/vfs/cpp/pseudo_dir.h>
#include <zircon/assert.h>
#include <zircon/status.h>

#include <algorithm>
#include <random>

#include "codec_factory_impl.h"
#include "codec_isolate.h"
#include "src/lib/fsl/io/device_watcher.h"
#include "src/lib/fxl/strings/concatenate.h"

namespace {

constexpr char kDeviceClass[] = "/dev/class/media-codec";
constexpr char kGpuDeviceClass[] = "/dev/class/gpu";
const char* kLogTag = "CodecFactoryApp";

struct SwVideoDecoderInfo {
  const char* mime_type;
  fuchsia::media::CodecProfile profile;
  uint32_t min_width;
  uint32_t min_height;
  uint32_t max_width;
  uint32_t max_height;
};
const SwVideoDecoderInfo kSwVideoDecoderInfos[] = {
    {
        .mime_type = "video/h264",  // VIDEO_ENCODING_H264
        .profile = fuchsia::media::CodecProfile::H264PROFILE_HIGH,
        .min_width = 32,
        .min_height = 32,
        // The decode performance will likely not be realtime at these dimensions.
        .max_width = 3840,
        .max_height = 2160,
    },
};

const char* CodecProfileToString(fuchsia::media::CodecProfile profile) {
  switch (profile) {
    case fuchsia::media::CodecProfile::H264PROFILE_BASELINE:
      return "H264PROFILE_BASELINE";
    case fuchsia::media::CodecProfile::H264PROFILE_MAIN:
      return "H264PROFILE_MAIN";
    case fuchsia::media::CodecProfile::H264PROFILE_EXTENDED:
      return "H264PROFILE_EXTENDED";
    case fuchsia::media::CodecProfile::H264PROFILE_HIGH:
      return "H264PROFILE_HIGH";
    case fuchsia::media::CodecProfile::H264PROFILE_HIGH10PROFILE:
      return "H264PROFILE_HIGH10PROFILE";
    case fuchsia::media::CodecProfile::H264PROFILE_HIGH422PROFILE:
      return "H264PROFILE_HIGH422PROFILE";
    case fuchsia::media::CodecProfile::H264PROFILE_HIGH444PREDICTIVEPROFILE:
      return "H264PROFILE_HIGH444PREDICTIVEPROFILE";
    case fuchsia::media::CodecProfile::H264PROFILE_SCALABLEBASELINE:
      return "H264PROFILE_SCALABLEBASELINE";
    case fuchsia::media::CodecProfile::H264PROFILE_SCALABLEHIGH:
      return "H264PROFILE_SCALABLEHIGH";
    case fuchsia::media::CodecProfile::H264PROFILE_STEREOHIGH:
      return "H264PROFILE_STEREOHIGH";
    case fuchsia::media::CodecProfile::H264PROFILE_MULTIVIEWHIGH:
      return "H264PROFILE_MULTIVIEWHIGH";
    case fuchsia::media::CodecProfile::VP8PROFILE_ANY:
      return "VP8PROFILE_ANY";
    case fuchsia::media::CodecProfile::VP9PROFILE_PROFILE0:
      return "VP9PROFILE_PROFILE0";
    case fuchsia::media::CodecProfile::VP9PROFILE_PROFILE1:
      return "VP9PROFILE_PROFILE1";
    case fuchsia::media::CodecProfile::VP9PROFILE_PROFILE2:
      return "VP9PROFILE_PROFILE2";
    case fuchsia::media::CodecProfile::VP9PROFILE_PROFILE3:
      return "VP9PROFILE_PROFILE3";
    case fuchsia::media::CodecProfile::HEVCPROFILE_MAIN:
      return "HEVCPROFILE_MAIN";
    case fuchsia::media::CodecProfile::HEVCPROFILE_MAIN10:
      return "HEVCPROFILE_MAIN10";
    case fuchsia::media::CodecProfile::HEVCPROFILE_MAIN_STILL_PICTURE:
      return "HEVCPROFILE_MAIN_STILL_PICTURE";
    case fuchsia::media::CodecProfile::MJPEG_BASELINE:
      return "MJPEG_BASELINE";
    default:
      return "UNKNOWN";
  }
}

fuchsia::mediacodec::CodecDescription CreateDeprecatedCodecDescriptionFromDetailedCodecDescription(
    fuchsia::mediacodec::DetailedCodecDescription& detailed) {
  fuchsia::mediacodec::CodecDescription deprecated;
  deprecated.codec_type = detailed.codec_type();
  deprecated.mime_type = detailed.mime_type();
  deprecated.is_hw = detailed.is_hw();
  switch (detailed.codec_type()) {
    case fuchsia::mediacodec::CodecType::DECODER:
      // Default to more-capable, but if any per-profile info indicates less-capable, aggregate by
      // marking less-capable.
      deprecated.can_stream_bytes_input = true;
      deprecated.can_find_start = true;
      deprecated.can_re_sync = true;
      deprecated.will_report_all_detected_errors = true;
      deprecated.split_header_handling = true;
      for (auto& profile : detailed.profile_descriptions().decoder_profile_descriptions()) {
        if (!profile.has_can_stream_bytes_input() || !profile.can_stream_bytes_input()) {
          deprecated.can_stream_bytes_input = false;
        }
        if (!profile.has_can_find_start() || !profile.can_find_start()) {
          deprecated.can_find_start = false;
        }
        if (!profile.has_can_re_sync() || !profile.can_re_sync()) {
          deprecated.can_re_sync = false;
        }
        if (!profile.has_will_report_all_detected_errors() ||
            !profile.will_report_all_detected_errors()) {
          deprecated.will_report_all_detected_errors = false;
        }
        if (!profile.has_split_header_handling() || !profile.split_header_handling()) {
          deprecated.split_header_handling = false;
        }
      }
      break;
    case fuchsia::mediacodec::CodecType::ENCODER:
      // These don't make sense for encoders, so set them all to false.  The ambiguity of these
      // fields appearing to apply to encoders when really they make no sense for encoders is
      // among the reasons we're deprecating OnCodecList.
      deprecated.can_stream_bytes_input = false;
      deprecated.can_find_start = false;
      deprecated.can_re_sync = false;
      deprecated.will_report_all_detected_errors = false;
      deprecated.split_header_handling = false;
  }
  return deprecated;
}

}  // namespace

// board_name_ initialization requires startup_context_ already initialized.
// policy_ initialization requires board_name_ already initialized.
CodecFactoryApp::CodecFactoryApp(async_dispatcher_t* dispatcher, ProdOrTest prod_or_test)
    : dispatcher_(dispatcher),
      prod_or_test_(prod_or_test),
      startup_context_(sys::ComponentContext::Create()),
      board_name_(GetBoardName()),
      policy_(this) {
  inspector_ =
      std::make_unique<inspect::ComponentInspector>(dispatcher_, inspect::PublishOptions{});
  inspector_->Health().StartingUp();
  hardware_factory_nodes_ = inspector_->root().CreateChild("hardware_factory_nodes");
  // Don't publish service or outgoing()->ServeFromStartupInfo() until after initial discovery is
  // done, else the pumping of the loop will drop the incoming request for CodecFactory before
  // AddPublicService() below has had a chance to register for it.

  zx_status_t status =
      outgoing_codec_aux_service_directory_parent_
          .AddPublicService<fuchsia::metrics::MetricEventLoggerFactory>(
              [this](fidl::InterfaceRequest<fuchsia::metrics::MetricEventLoggerFactory> request) {
                ZX_DEBUG_ASSERT(startup_context_);
                FX_SLOG(INFO, kLogTag,
                        "codec_factory handling request for MetricEventLoggerFactory" FX_KV(
                            "tag", kLogTag),
                        FX_KV("handle value", request.channel().get()));
                startup_context_->svc()->Connect(std::move(request));
              });
  outgoing_codec_aux_service_directory_ =
      outgoing_codec_aux_service_directory_parent_.GetOrCreateDirectory("svc");

  // Else codec_factory won't be able to provide what codecs expect to be able to rely on.
  ZX_ASSERT(status == ZX_OK);

  DiscoverMagmaCodecDriversAndListenForMoreAsync();
  DiscoverMediaCodecDriversAndListenForMoreAsync();
}

void CodecFactoryApp::PublishService() {
  // We delay doing this until we're completely ready to add services.
  // We _rely_ on the driver to either fail the channel or respond to GetDetailedCodecDescriptions.
  ZX_DEBUG_ASSERT(existing_devices_discovered_);
  zx_status_t status =
      startup_context_->outgoing()->AddPublicService<fuchsia::mediacodec::CodecFactory>(
          [this](fidl::InterfaceRequest<fuchsia::mediacodec::CodecFactory> request) {
            // The CodecFactoryImpl is self-owned and will self-delete when the
            // channel closes or an error occurs.
            CodecFactoryImpl::CreateSelfOwned(this, startup_context_.get(), std::move(request));
          });
  // else this codec_factory is useless
  ZX_ASSERT(status == ZX_OK);
  inspector_->Health().Ok();
  if (prod_or_test_ == ProdOrTest::kProduction) {
    status = startup_context_->outgoing()->ServeFromStartupInfo();
    ZX_ASSERT(status == ZX_OK);
  }
}

// All of the current supported hardware and software decoders, randomly shuffled
// so as to avoid clients depending on the order.
// TODO(schottm): send encoders as well
std::vector<fuchsia::mediacodec::CodecDescription> CodecFactoryApp::MakeCodecList() const {
  std::vector<fuchsia::mediacodec::CodecDescription> codecs;

  for (const auto& info : kSwVideoDecoderInfos) {
    codecs.push_back({
        .codec_type = fuchsia::mediacodec::CodecType::DECODER,
        .mime_type = info.mime_type,

        // TODO(schottm): can some of these be true?
        .can_stream_bytes_input = false,
        .can_find_start = false,
        .can_re_sync = false,
        .will_report_all_detected_errors = false,

        .is_hw = false,
        .split_header_handling = true,
    });
  }

  for (const auto& factory : hw_factories_) {
    for (const auto& codec : factory->hw_codecs) {
      codecs.push_back(codec->deprecated_codec_description);
    }
  }

  auto rng = std::default_random_engine();
  std::shuffle(codecs.begin(), codecs.end(), rng);

  return codecs;
}

std::vector<fuchsia::mediacodec::DetailedCodecDescription>
CodecFactoryApp::MakeDetailedCodecDescriptions() const {
  std::vector<fuchsia::mediacodec::DetailedCodecDescription> codec_descriptions;

  for (const auto& info : kSwVideoDecoderInfos) {
    fuchsia::mediacodec::DetailedCodecDescription description;
    description.set_codec_type(fuchsia::mediacodec::CodecType::DECODER);
    description.set_mime_type(info.mime_type);
    description.set_is_hw(false);
    fuchsia::mediacodec::DecoderProfileDescription profile_description;
    profile_description.set_profile(info.profile);
    profile_description.set_min_image_size({info.min_width, info.min_height});
    profile_description.set_max_image_size({info.max_width, info.max_height});
    // We leave the rest of the fields un-set intentionally, since clients must accept a non-set
    // field and know that means what the comments on the field in the FIDL file say it means (no
    // programmatic field defaults).
    std::vector<fuchsia::mediacodec::DecoderProfileDescription> profiles;
    profiles.push_back(std::move(profile_description));
    fuchsia::mediacodec::ProfileDescriptions profile_descriptions;
    profile_descriptions.set_decoder_profile_descriptions(std::move(profiles));
    description.set_profile_descriptions(std::move(profile_descriptions));
    codec_descriptions.push_back(std::move(description));
  }

  for (const auto& factory : hw_factories_) {
    for (const auto& codec : factory->hw_codecs) {
      // Need to clone the |DetailedCodecDescription| since it is not copyable
      fuchsia::mediacodec::DetailedCodecDescription detailed_description;
      ZX_ASSERT(codec->detailed_description.Clone(&detailed_description) == ZX_OK);
      codec_descriptions.push_back(std::move(detailed_description));
    }
  }

  return codec_descriptions;
}

const fuchsia::mediacodec::CodecFactoryPtr* CodecFactoryApp::FindHwCodec(
    fit::function<bool(const fuchsia::mediacodec::DetailedCodecDescription&)> is_match) {
  for (auto& hw_factory : hw_factories_) {
    // HW codecs are connected to using factory, not by launching a component using the URL.
    if (!hw_factory->component_url.empty()) {
      continue;
    }

    auto iter = std::find_if(hw_factory->hw_codecs.begin(), hw_factory->hw_codecs.end(),
                             [&is_match](const std::unique_ptr<CodecListEntry>& entry) -> bool {
                               return is_match(entry->detailed_description);
                             });

    if (iter != hw_factory->hw_codecs.end()) {
      return hw_factory->codec_factory.get();
    }
  }

  return nullptr;
}

std::optional<std::string> CodecFactoryApp::FindHwIsolate(
    fit::function<bool(const fuchsia::mediacodec::DetailedCodecDescription&)> is_match) {
  for (auto& hw_factory : hw_factories_) {
    // Isolate codecs are connected by launching a component using the URL.
    if (hw_factory->component_url.empty()) {
      continue;
    }

    auto iter = std::find_if(hw_factory->hw_codecs.begin(), hw_factory->hw_codecs.end(),
                             [&is_match](const std::unique_ptr<CodecListEntry>& entry) -> bool {
                               return is_match(entry->detailed_description);
                             });

    if (iter != hw_factory->hw_codecs.end()) {
      return hw_factory->component_url;
    }
  }

  return std::nullopt;
}

void CodecFactoryApp::IdledCodecDiscovery() {
  ZX_ASSERT(num_codec_discoveries_in_flight_ >= 1);
  if (--num_codec_discoveries_in_flight_ == 0) {
    // The idle_callback indicates that all pre-existing devices have been
    // seen, and by the time this item reaches the front of the discovery
    // queue, all pre-existing devices have all been processed.
    device_discovery_queue_.emplace_back(std::make_unique<DeviceDiscoveryEntry>());
    PostDiscoveryQueueProcessing();
  }
}

void CodecFactoryApp::DiscoverMediaCodecDriversAndListenForMoreAsync() {
  num_codec_discoveries_in_flight_++;
  // We use fsl::DeviceWatcher::CreateWithIdleCallback() instead of fsl::DeviceWatcher::Create()
  // because the CodecFactory service is started on demand, and we don't want to start serving
  // CodecFactory until we've discovered and processed all existing media-codec devices.  That way,
  // the first time a client requests a HW-backed codec, we robustly consider all codecs provided by
  // pre-existing devices.  The request for a HW-backed Codec will have a much higher probability of
  // succeeding vs. if we just discovered pre-existing devices async.  This doesn't prevent the
  // possibility that the device might not exist at the moment the CodecFactory is started, but as
  // long as the device does exist by then, this will ensure the device's codecs are considered,
  // including for the first client request.
  device_watcher_ = fsl::DeviceWatcher::CreateWithIdleCallback(
      kDeviceClass,
      [this](const fidl::ClientEnd<fuchsia_io::Directory>& dir, const std::string& filename) {
        fuchsia::hardware::mediacodec::DevicePtr device_interface;
        if (zx_status_t status =
                fdio_service_connect_at(dir.channel().get(), filename.c_str(),
                                        device_interface.NewRequest().TakeChannel().release());
            status != ZX_OK) {
          FX_PLOGS(ERROR, status) << "Failed to connect to device '" << filename << "'";
          return;
        }

        fidl::InterfaceHandle<fuchsia::io::Directory> aux_service_directory;
        if (zx_status_t status = outgoing_codec_aux_service_directory_->Serve(
                fuchsia::io::OpenFlags::RIGHT_READABLE | fuchsia::io::OpenFlags::RIGHT_WRITABLE |
                    fuchsia::io::OpenFlags::DIRECTORY,
                aux_service_directory.NewRequest().TakeChannel(), dispatcher_);
            status != ZX_OK) {
          FX_PLOGS(ERROR, status) << "outgoing_codec_aux_service_directory_.Serve() failed";
          return;
        }

        auto discovery_entry = std::make_unique<DeviceDiscoveryEntry>();
        discovery_entry->device_path = fxl::Concatenate({kDeviceClass, "/", filename});
        discovery_entry->codec_factory = std::make_shared<fuchsia::mediacodec::CodecFactoryPtr>();

        // It's ok for a codec that doesn't need the aux service directory to just close the client
        // handle to it, so there's no need to attempt to detect a codec closing the aux service
        // directory client end.
        //
        // TODO(dustingreen): Combine these two calls into "Connect" and use FIDL table with the
        // needed fields.
        device_interface->SetAuxServiceDirectory(std::move(aux_service_directory));
        device_interface->GetCodecFactory(
            discovery_entry->codec_factory->NewRequest(dispatcher()).TakeChannel());

        // From here on in the current lambda, we're doing stuff that can't fail
        // here locally (at least, not without exiting the whole process).  The
        // error handler will handle channel error async.

        discovery_entry->codec_factory->set_error_handler(
            [this, device_path = discovery_entry->device_path,
             factory = discovery_entry->codec_factory.get()](zx_status_t status) {
              // Any given factory won't be in both lists, but will be in one or
              // the other by the time this error handler runs.
              device_discovery_queue_.remove_if(
                  [factory](const std::unique_ptr<DeviceDiscoveryEntry>& entry) {
                    return factory == entry->codec_factory.get();
                  });
              // Perhaps the removed discovery item was the first item in the
              // list; maybe now the new first item in the list can be
              // processed.
              PostDiscoveryQueueProcessing();

              hw_factories_.remove_if(
                  [factory](const std::unique_ptr<CodecFactoryEntry>& factory_entry) {
                    return factory == factory_entry->codec_factory.get();
                  });
            });

        // Queue up a call to |GetDetailedCodecDescriptions()| and store the output in the
        // discovery_entry.
        FX_LOGS(INFO) << "Calling GetDetailedCodecDescriptions for "
                      << discovery_entry->device_path;
        (*discovery_entry->codec_factory)
            ->GetDetailedCodecDescriptions(
                [this, discovery_entry = discovery_entry.get()](
                    fuchsia::mediacodec::CodecFactoryGetDetailedCodecDescriptionsResponse
                        response) {
                  ZX_ASSERT(response.has_codecs());
                  ZX_ASSERT(response.mutable_codecs());
                  FX_LOGS(INFO) << "GetDetailedCodecDescriptions response received for "
                                << discovery_entry->device_path;
                  discovery_entry->detailed_codec_descriptions =
                      std::move(*response.mutable_codecs());
                  // In case discovery_entry is the first item which is now ready to
                  // process, process the discovery queue.
                  PostDiscoveryQueueProcessing();
                });

        device_discovery_queue_.emplace_back(std::move(discovery_entry));
      },
      [this] { IdledCodecDiscovery(); });
}

void CodecFactoryApp::TeardownMagmaCodec(
    const std::shared_ptr<fuchsia::gpu::magma::IcdLoaderDevicePtr>& magma_device) {
  // Any given magma device won't be in both lists, but will be in one or
  // the other by the time this error handler runs.
  device_discovery_queue_.remove_if(
      [&magma_device](const std::unique_ptr<DeviceDiscoveryEntry>& entry) {
        return magma_device.get() == entry->magma_device.get();
      });

  hw_factories_.remove_if([&magma_device](const std::unique_ptr<CodecFactoryEntry>& factory_entry) {
    return magma_device.get() == factory_entry->magma_device.get();
  });

  // Perhaps the removed discovery item was the first item in the
  // list; maybe now the new first item in the list can be
  // processed.
  PostDiscoveryQueueProcessing();
}

void CodecFactoryApp::DiscoverMagmaCodecDriversAndListenForMoreAsync() {
  num_codec_discoveries_in_flight_++;
  gpu_device_watcher_ = fsl::DeviceWatcher::CreateWithIdleCallback(
      kGpuDeviceClass,
      [this](const fidl::ClientEnd<fuchsia_io::Directory>& dir, const std::string& filename) {
        auto magma_device = std::make_shared<fuchsia::gpu::magma::IcdLoaderDevicePtr>();
        zx_status_t status =
            fdio_service_connect_at(dir.channel().get(), filename.c_str(),
                                    magma_device->NewRequest().TakeChannel().release());
        if (status != ZX_OK) {
          FX_PLOGS(ERROR, status) << "Failed to connect to device '" << filename << "'";
          return;
        }

        auto discovery_entry = std::make_unique<DeviceDiscoveryEntry>();
        discovery_entry->device_path = fxl::Concatenate({kGpuDeviceClass, "/", filename});
        discovery_entry->magma_device = magma_device;
        discovery_entry->magma_device->set_error_handler(
            [this, magma_device](zx_status_t status) { TeardownMagmaCodec(magma_device); });
        (*magma_device)
            ->GetIcdList([this, discovery_entry = discovery_entry.get(), magma_device,
                          device_path = discovery_entry->device_path](
                             const std::vector<fuchsia::gpu::magma::IcdInfo>& icd_infos) {
              bool found_media_icd = false;
              for (auto& icd_entry : icd_infos) {
                if (!icd_entry.has_flags() || !icd_entry.has_component_url())
                  continue;
                if (!(icd_entry.flags() &
                      fuchsia::gpu::magma::IcdFlags::SUPPORTS_MEDIA_CODEC_FACTORY)) {
                  continue;
                }
                discovery_entry->component_url = icd_entry.component_url();
                ForwardToIsolate(
                    icd_entry.component_url(), IsolateType::kMagma, startup_context_.get(),
                    [this, magma_device, device_path](fuchsia::mediacodec::CodecFactoryPtr ptr) {
                      auto it = std::find_if(
                          device_discovery_queue_.begin(), device_discovery_queue_.end(),
                          [magma_device](const std::unique_ptr<DeviceDiscoveryEntry>& entry) {
                            return magma_device.get() == entry->magma_device.get();
                          });
                      if (it == device_discovery_queue_.end()) {
                        // Device was removed from the queue due to the magma error handler running.
                        return;
                      }
                      auto discovery_entry = it->get();

                      discovery_entry->codec_factory =
                          std::make_shared<fuchsia::mediacodec::CodecFactoryPtr>();
                      discovery_entry->codec_factory->Bind(ptr.Unbind());
                      discovery_entry->codec_factory->set_error_handler(
                          [this, device_path, magma_device](zx_status_t status) {
                            TeardownMagmaCodec(magma_device);
                          });
                      // Queue up a call to |GetDetailedCodecDescriptions()| and store the output
                      // in the discovery_entry.
                      FX_LOGS(INFO) << "Calling GetDetailedCodecDescriptions for "
                                    << discovery_entry->component_url;
                      (*discovery_entry->codec_factory)
                          ->GetDetailedCodecDescriptions(
                              [this, discovery_entry](
                                  fuchsia::mediacodec::
                                      CodecFactoryGetDetailedCodecDescriptionsResponse response) {
                                ZX_ASSERT(response.has_codecs());
                                ZX_ASSERT(response.mutable_codecs());
                                FX_LOGS(INFO)
                                    << "GetDetailedCodecDescriptions response received for "
                                    << discovery_entry->component_url;
                                discovery_entry->detailed_codec_descriptions =
                                    std::move(*response.mutable_codecs());
                                // In case discovery_entry is the first item which is now ready to
                                // process, process the discovery queue.
                                PostDiscoveryQueueProcessing();
                              });
                    },
                    [this, magma_device]() { TeardownMagmaCodec(magma_device); });
                found_media_icd = true;
                // Only support a single codec factory per magma device.
                break;
              }
              if (!found_media_icd) {
                TeardownMagmaCodec(magma_device);
              }
            });
        device_discovery_queue_.emplace_back(std::move(discovery_entry));
      },
      [this] { IdledCodecDiscovery(); });
}

void CodecFactoryApp::PostDiscoveryQueueProcessing() {
  async::PostTask(dispatcher_, fit::bind_member<&CodecFactoryApp::ProcessDiscoveryQueue>(this));
}

void CodecFactoryApp::ProcessDiscoveryQueue() {
  // Both startup and steady-state use this processing loop.
  //
  // In startup, we care about ordering of the discovery queue because we want
  // to allow serving of CodecFactory as soon as all pre-existing devices are
  // done processing.  We care that pre-existing devices are before
  // newly-discovered devices in the queue.  As far as startup is concerned,
  // there are other ways we could track this without using a queue, but a queue
  // works, and using the queue allows startup to share code with steady-state.
  //
  // In steady-state, we care (a little) about ordering of the discovery queue
  // because we want (to a limited degree, for now) to prefer a
  // more-recently-discovered device over a less-recently-discovered device (for
  // now at least), so to make that robust, we preserve the device discovery
  // order through the codec discovery sequence, to account for the possibility
  // that an previously discovered device may have only just recently responded
  // to GetDetailedCodecDescriptions before failing; without the
  // device_discovery_queue_ that previously-discovered device's response could
  // re-order vs. the replacement device's response.
  //
  // The device_discovery_queue_ marginally increases the odds of a client
  // request picking up a replacement devhost instead of an old devhost that
  // failed quickly and which we haven't yet noticed is gone.  This devhost
  // replacement case is the main motivation for caring about the device
  // discovery order in the first place (at least for now), since it should be
  // robustly the case that discovery of the old devhost happens before
  // discovery of the replacement devhost.
  //
  // The ordering of the hw_codec_ list is the main way in which
  // more-recently-discovered codecs are preferred over less-recently-discovered
  // codecs.  The device_discovery_queue_ just makes the hw_codec_ ordering
  // exactly correspond to the device discovery order (reversed) even when
  // devices are discovered near each other in time.
  //
  // None of this changes the fact that a replacement devhost's arrival can race
  // with a client's request, so if a devhost fails and is replaced, it's quite
  // possible the client will see the Codec interface just fail.  Even if this
  // were mitigated, it wouldn't change the fact that a devhost failure later
  // would result in Codec interface failure at that time, so failures near the
  // start aren't really much different than async failures later. It can make
  // sense for a client to retry a low number of times (if the client wants to
  // work despite a devhost not always fully working), even if the Codec failure
  // happens quite early.
  while (!device_discovery_queue_.empty()) {
    std::unique_ptr<DeviceDiscoveryEntry>& discovered_device = device_discovery_queue_.front();
    if (!discovered_device->codec_factory && !discovered_device->magma_device) {
      // All pre-existing devices have been processed.
      //
      // Now the CodecFactory can begin serving (shortly).
      if (!existing_devices_discovered_) {
        existing_devices_discovered_ = true;
        FX_LOGS(INFO) << "CodecFactory calling PublishService()";
        PublishService();
      }
      // The marker has done its job, so remove the marker.
      device_discovery_queue_.pop_front();
      return;
    }

    // Wait for detailed_codec_descriptions.  We don't wait for driver_codec_list, which is
    // generated from detailed_codec_descriptions below.
    if (!discovered_device->detailed_codec_descriptions) {
      // The first item is not yet ready. The current method will get re-posted
      // when the first item is potentially ready.
      return;
    }

    if (!discovered_device->component_url.empty()) {
      // If there's a component URL then a new instance will be launched for every codec, so
      // codec_factory won't be used anymore.
      discovered_device->codec_factory = {};
    }

    FX_DCHECK(!discovered_device->device_path.empty());

    // Create the hardware codec factory that these codecs will belong to
    auto hw_codec_factory = std::make_unique<CodecFactoryEntry>();
    hw_codec_factory->component_url = discovered_device->component_url;
    hw_codec_factory->codec_factory = discovered_device->codec_factory;
    hw_codec_factory->magma_device = discovered_device->magma_device;

    // Device paths are always unique and must be provided for hardware factories
    hw_codec_factory->factory_node =
        hardware_factory_nodes_.CreateChild(discovered_device->device_path);

    const std::string& device_path =
        !discovered_device->device_path.empty() ? discovered_device->device_path : "N/A";
    hw_codec_factory->factory_node.RecordString("device_path", device_path);

    const std::string& component_url =
        !discovered_device->component_url.empty() ? discovered_device->component_url : "N/A";
    hw_codec_factory->factory_node.RecordString("component_url", component_url);

    // All codecs must implement GetDetailedCodecDescriptions.  We ignore any OnCodecList from each
    // codec in favor of building an OnCodecList from GetDetailedCodecDescriptions responses, so
    // that each codec (roughly speaking) can stop sending the deprecated OnCodecList before all
    // clients have stopped listening to OnCodecList.
    FX_CHECK(discovered_device->detailed_codec_descriptions);

    while (!discovered_device->detailed_codec_descriptions->empty()) {
      auto detailed_description = std::move(discovered_device->detailed_codec_descriptions->back());
      discovered_device->detailed_codec_descriptions->pop_back();

      FX_LOGS(INFO) << "Registering "
                    << (detailed_description.codec_type() == fuchsia::mediacodec::CodecType::DECODER
                            ? "decoder"
                            : "encoder")
                    << ", mime_type: " << detailed_description.mime_type()
                    << ", device_path: " << discovered_device->device_path
                    << ", component url: " << discovered_device->component_url;

      if (!detailed_description.has_profile_descriptions()) {
        FX_LOGS(WARNING) << "!has_profile_descriptions for " << detailed_description.mime_type()
                         << " "
                         << ((detailed_description.codec_type() ==
                              fuchsia::mediacodec::CodecType::DECODER)
                                 ? "DECODER"
                                 : "ENCODER");
        continue;
      }

      auto deprecated_codec_description =
          CreateDeprecatedCodecDescriptionFromDetailedCodecDescription(detailed_description);

      auto& parent_node = hw_codec_factory->factory_node;
      inspect::Node node = parent_node.CreateChild(detailed_description.mime_type());
      node.RecordString("type",
                        detailed_description.codec_type() == fuchsia::mediacodec::CodecType::DECODER
                            ? "decoder"
                            : "encoder");
      node.RecordString("mime_type", detailed_description.mime_type());

      // Populate the detailed inspect values, which is different for decoders vs. encoders.
      switch (detailed_description.codec_type()) {
        case fuchsia::mediacodec::CodecType::DECODER:
          node.RecordChild("supported_profiles", [&detailed_description](
                                                     inspect::Node& supported_profile_nodes) {
            if (!detailed_description.has_profile_descriptions()) {
              // A warning was alraedy printed above.
              return;
            }
            if (!detailed_description.profile_descriptions().is_decoder_profile_descriptions()) {
              FX_LOGS(WARNING) << "DECODER !is_decoder_profile_descriptions for "
                               << detailed_description.mime_type();
              return;
            }
            uint32_t profile_ordinal = 0u;
            const auto& profiles =
                detailed_description.profile_descriptions().decoder_profile_descriptions();
            for (const auto& profile : profiles) {
              supported_profile_nodes.RecordChild(
                  std::to_string(profile_ordinal), [&profile](inspect::Node& profile_node) {
                    FX_DCHECK(profile.has_profile());
                    profile_node.RecordString("profile", CodecProfileToString(profile.profile()));

                    if (profile.has_min_image_size()) {
                      const auto& min_size = profile.min_image_size();
                      profile_node.RecordUint("min_width", min_size.width);
                      profile_node.RecordUint("min_height", min_size.height);
                    }

                    if (profile.has_max_image_size()) {
                      const auto& max_size = profile.max_image_size();
                      profile_node.RecordUint("max_width", max_size.width);
                      profile_node.RecordUint("max_height", max_size.height);
                    }
                  });
              profile_ordinal += 1u;
            }
          });
          break;
        case fuchsia::mediacodec::CodecType::ENCODER:
          node.RecordChild("supported_profiles", [&detailed_description](
                                                     inspect::Node& supported_profile_nodes) {
            if (!detailed_description.has_profile_descriptions()) {
              // A warning was already printed above.
              return;
            }
            if (!detailed_description.profile_descriptions().is_encoder_profile_descriptions()) {
              FX_LOGS(WARNING) << "ENCODER !is_encoder_profile_descriptions for "
                               << detailed_description.mime_type();
              return;
            }
            uint32_t profile_ordinal = 0u;
            const auto& profiles =
                detailed_description.profile_descriptions().encoder_profile_descriptions();
            for (const auto& profile : profiles) {
              supported_profile_nodes.RecordChild(
                  std::to_string(profile_ordinal), [&profile](inspect::Node& profile_node) {
                    FX_DCHECK(profile.has_profile());
                    profile_node.RecordString("profile", CodecProfileToString(profile.profile()));
                  });
              profile_ordinal += 1u;
            }
          });
          break;
      }

      hw_codec_factory->hw_codecs.emplace_front(std::make_unique<CodecListEntry>(CodecListEntry{
          .detailed_description = std::move(detailed_description),
          .codec_node = std::move(node),
          .deprecated_codec_description = std::move(deprecated_codec_description),
      }));
    }

    hw_factories_.push_back(std::move(hw_codec_factory));
    device_discovery_queue_.pop_front();
  }
}

// This is called during field initialization portion of the constructor, so needs to avoid reading
// any fields that are not yet initialized.
std::string CodecFactoryApp::GetBoardName() {
  fuchsia::sysinfo::SysInfoSyncPtr sysinfo;
  zx_status_t status =
      startup_context_->svc()->Connect<fuchsia::sysinfo::SysInfo>(sysinfo.NewRequest());
  // CodecFactoryApp's process can't necessarily work correctly without the board name.
  ZX_ASSERT(status == ZX_OK);
  fidl::StringPtr board_name;
  zx_status_t fidl_status = sysinfo->GetBoardName(&status, &board_name);
  if (fidl_status != ZX_OK || status != ZX_OK) {
    // This path is only taken if CodecFactory can't contact fuchsia.sysinfo.SysInfo.  Most often
    // this happens in tests that don't correctly route the capability for protocol
    // fuchsia.sysinfo.SysInfo.
    FX_LOGS(WARNING) << "#############################";
    FX_LOGS(WARNING) << "sysinfo->GetBoardName() failed.  "
                        "CodecFactoryApp needs access to fuchsia.sysinfo.SysInfo.  fidl_status: "
                     << fidl_status << " status: " << status;
    FX_LOGS(WARNING) << "#############################";
    return "<UNKNOWN>";
  }
  ZX_ASSERT(fidl_status == ZX_OK && status == ZX_OK);
  return board_name.value();
}