// Copyright 2021 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 <fidl/fuchsia.component.decl/cpp/fidl.h>
#include <fidl/fuchsia.component.resolution/cpp/wire.h>
#include <fidl/fuchsia.driver.test/cpp/fidl.h>
#include <fidl/fuchsia.io/cpp/wire.h>
#include <fidl/fuchsia.pkg/cpp/fidl.h>
#include <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
#include <lib/component/incoming/cpp/clone.h>
#include <lib/component/incoming/cpp/protocol.h>
#include <lib/component/outgoing/cpp/outgoing_directory.h>
#include <lib/fdio/directory.h>
#include <lib/syslog/cpp/macros.h>
#include <lib/zx/vmo.h>
#include <zircon/errors.h>
#include <zircon/status.h>
#include <zircon/types.h>

#include <cstdint>
#include <format>
#include <fstream>
#include <list>
#include <string_view>
#include <unordered_set>
#include <vector>

#include <fbl/unique_fd.h>
#include <rapidjson/document.h>
#include <src/lib/files/directory.h>
#include <src/lib/files/file.h>

namespace {

zx::result<fidl::ClientEnd<fuchsia_io::Directory>> OpenPkgDir() {
  auto endpoints = fidl::CreateEndpoints<fuchsia_io::Directory>();
  if (endpoints.is_error()) {
    return zx::error(ZX_ERR_INTERNAL);
  }
  zx_status_t status = fdio_open3(
      "/pkg",
      static_cast<uint64_t>(fuchsia_io::wire::Flags::kProtocolDirectory |
                            fuchsia_io::wire::kPermReadable | fuchsia_io::wire::kPermExecutable),
      endpoints->server.TakeChannel().release());
  if (status != ZX_OK) {
    return zx::error(ZX_ERR_INTERNAL);
  }
  return zx::ok(std::move(endpoints->client));
}

struct ClientListEntry {
  fidl::ClientEnd<fuchsia_io::Directory> client;
  std::string url_prefix;
  std::string pkg_name;
};

struct BootAndBaseConfigResult {
  std::vector<std::string> boot_drivers;
  std::vector<std::string> base_drivers;
};

class DriverLists : public fidl::WireServer<fuchsia_driver_test::DriverLists> {
 public:
  explicit DriverLists(BootAndBaseConfigResult lists) : lists_(std::move(lists)) {}
  void GetDriverLists(GetDriverListsCompleter::Sync& completer) override {
    fidl::Arena arena;
    completer.ReplySuccess(fidl::ToWire(arena, lists_.boot_drivers),
                           fidl::ToWire(arena, lists_.base_drivers));
  }

 private:
  BootAndBaseConfigResult lists_;
};

class FakeComponentResolver final
    : public fidl::WireServer<fuchsia_component_resolution::Resolver> {
 public:
  explicit FakeComponentResolver(fidl::ClientEnd<fuchsia_io::Directory> boot_dir,
                                 fidl::ClientEnd<fuchsia_io::Directory> test_pkg_dir)
      : boot_dir_(std::move(boot_dir)), test_pkg_dir_(std::move(test_pkg_dir)) {}

 private:
  void handle_unknown_method(
      fidl::UnknownMethodMetadata<fuchsia_component_resolution::Resolver> metadata,
      fidl::UnknownMethodCompleter::Sync& completer) override {
    FX_LOG_KV(WARNING, "Unknown Resolver request", FX_KV("ordinal", metadata.method_ordinal));
  }

  void Resolve(ResolveRequestView request, ResolveCompleter::Sync& completer) override {
    std::string_view kTestPackagePrefix = "dtr-test-pkg://fuchsia.com/";
    std::string_view kBootPrefix = "fuchsia-boot:///";
    std::string_view kPkgPrefix = "fuchsia-pkg://fuchsia.com/";
    std::string_view relative_path = request->component_url.get();
    FX_LOG_KV(DEBUG, "Resolving", FX_KV("url", relative_path));

    if (!cpp20::starts_with(relative_path, kTestPackagePrefix) &&
        !cpp20::starts_with(relative_path, kBootPrefix) &&
        !cpp20::starts_with(relative_path, kPkgPrefix)) {
      FX_LOG_KV(ERROR, "FakeComponentResolver request not supported.",
                FX_KV("url", std::string(relative_path).c_str()));
      completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kInvalidArgs);
      return;
    }

    std::string_view pkg_url;
    fidl::ClientEnd<fuchsia_io::Directory> dir_to_use;

    // kTestPackagePrefix can resolve items from the test package, whether they are in the
    // package directly or part of a subpackage.
    if (cpp20::starts_with(relative_path, kTestPackagePrefix)) {
      relative_path.remove_prefix(kTestPackagePrefix.length());

      // The internal client is used for both direct and subpackage.
      auto internal_client = component::Connect<fuchsia_driver_test::Internal>();
      if (internal_client.is_error()) {
        FX_LOG_KV(ERROR, "Failed to connect to internal protocol.");
        completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kInternal);
        return;
      }

      if (!cpp20::starts_with(relative_path, "#")) {
        // This is a subpackage of the test so we have to use its resolution context to resolve the
        // subpackage.
        ResolveSubpackage(relative_path, *internal_client, completer);
        return;
      }

      // Remove the "#"
      relative_path.remove_prefix(1);

      zx::result<fidl::ClientEnd<fuchsia_io::Directory>> dir_clone_result =
          component::Clone(test_pkg_dir_);
      if (dir_clone_result.is_error()) {
        FX_LOG_KV(ERROR, "Failed to clone directory.");
        completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kInternal);
        return;
      }
      dir_to_use = std::move(dir_clone_result.value());
    } else {
      // Legacy resolver logic:
      // Looks at the prefix to determine which directory to look in (pkg or
      // boot), then looks at the path following '#' to find the fragment path within that
      // directory. It's assumed that the components can be found by the fragment path.
      bool is_boot = cpp20::starts_with(relative_path, kBootPrefix);
      size_t pos = relative_path.find('#');
      pkg_url = relative_path.substr(0, pos);
      relative_path.remove_prefix(pos + 1);

      zx::result<fidl::ClientEnd<fuchsia_io::Directory>> dir_clone_result;
      if (is_boot) {
        dir_clone_result = component::Clone(boot_dir_);
      } else {
        dir_clone_result = OpenPkgDir();
      }

      if (dir_clone_result.is_error()) {
        FX_LOG_KV(ERROR, "Failed to clone directory.");
        completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kInternal);
        return;
      }
      dir_to_use = std::move(dir_clone_result.value());
    }

    if (!dir_to_use.is_valid()) {
      FX_LOG_KV(ERROR, "Failed to set dir_to_use.");
    }

    zx::result manifest_vmo = ReadFileToVmo(relative_path, dir_to_use.channel().get());
    if (manifest_vmo.is_error()) {
      FX_LOG_KV(ERROR, "Failed to read manifest.",
                FX_KV("manifest", std::string(relative_path).c_str()));
      completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kIo);
      return;
    }

    uint64_t manifest_size;
    zx_status_t status = manifest_vmo->get_prop_content_size(&manifest_size);
    if (status != ZX_OK) {
      FX_LOG_KV(ERROR, "Failed to get vmo size.",
                FX_KV("manifest", std::string(relative_path).c_str()));
      completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kIo);
      return;
    }

    std::vector<uint8_t> manifest;
    manifest.resize(manifest_size);
    status = manifest_vmo->read(manifest.data(), 0, manifest_size);
    if (status != ZX_OK) {
      FX_LOG_KV(ERROR, "Failed to read manifest vmo.",
                FX_KV("manifest", std::string(relative_path).c_str()));
      completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kIo);
      return;
    }

    auto declaration = fidl::Unpersist<fuchsia_component_decl::Component>(manifest);
    if (declaration.is_error()) {
      FX_LOG_KV(ERROR, "Failed to parse component manifest.",
                FX_KV("manifest", std::string(relative_path).c_str()));
      completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kInvalidManifest);
      return;
    }

    // Check if there is a config file associated with the driver, and read if it exists.
    uint64_t config_size = 0;
    zx::vmo config_vmo;

    if (declaration->config() &&
        declaration->config()->value_source()->package_path().has_value()) {
      std::string config_path = declaration->config()->value_source()->package_path().value();
      zx::result config_file = ReadFileToVmo(config_path, dir_to_use.channel().get());
      if (config_file.is_error()) {
        FX_LOG_KV(ERROR, "Failed to read config vmo.", FX_KV("config", config_path.c_str()));
        completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kIo);
        return;
      }

      status = config_file->get_prop_content_size(&config_size);
      if (status != ZX_OK) {
        FX_LOG_KV(ERROR, "Failed to get vmo size.", FX_KV("config", config_path.c_str()));
        completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kIo);
        return;
      }

      config_vmo = std::move(*config_file);
    }

    // Not all boot components resolved by this resolver are packaged (e.g. root.cm) so they do
    // not have an ABI revision. As a workaround, apply the ABI revision of this package so
    // components can pass runtime ABI compatibility checks during testing.
    std::ifstream abi_revision_file("/pkg/meta/fuchsia.abi/abi-revision");
    if (!abi_revision_file) {
      FX_LOG_KV(ERROR, "Failed to open abi-revision.");
      completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kIo);
      return;
    }

    uint64_t abi_revision;
    abi_revision_file.read(reinterpret_cast<char*>(&abi_revision), sizeof(abi_revision));
    if (!abi_revision_file) {
      FX_LOG_KV(ERROR, "Failed to read abi-revision.");
      completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kIo);
      return;
    }
    abi_revision_file.close();

    fidl::Arena arena;
    auto package = fuchsia_component_resolution::wire::Package::Builder(arena)
                       .url(pkg_url)
                       .directory(std::move(dir_to_use))
                       .Build();

    auto builder =
        fuchsia_component_resolution::wire::Component::Builder(arena)
            .url(request->component_url)
            .abi_revision(abi_revision)
            .decl(fuchsia_mem::wire::Data::WithBuffer(arena,
                                                      fuchsia_mem::wire::Buffer{
                                                          .vmo = std::move(*manifest_vmo),
                                                          .size = manifest_size,
                                                      }))
            .package(package);

    if (config_vmo.is_valid()) {
      builder.config_values(
          fuchsia_mem::wire::Data::WithBuffer(arena, fuchsia_mem::wire::Buffer{
                                                         .vmo = std::move(config_vmo),
                                                         .size = config_size,
                                                     }));
    }

    auto component = builder.Build();

    FX_LOG_KV(DEBUG, "Successfully Resolved", FX_KV("url", relative_path));
    completer.ReplySuccess(component);
  }

  void ResolveWithContext(ResolveWithContextRequestView request,
                          ResolveWithContextCompleter::Sync& completer) override {
    FX_LOG_KV(ERROR, "FakeComponentResolver does not currently support ResolveWithContext");
    completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kInvalidArgs);
  }

  static void ResolveSubpackage(
      std::string_view relative_path,
      fidl::UnownedClientEnd<fuchsia_driver_test::Internal> internal_client,
      ResolveCompleter::Sync& completer) {
    auto resolution_context = fidl::WireCall(internal_client)->GetTestResolutionContext();
    if (!resolution_context.ok()) {
      FX_LOG_KV(ERROR, "Failed to get resolution context.",
                FX_KV("description", resolution_context.FormatDescription().c_str()));
      completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kInternal);
      return;
    }

    if (resolution_context.value().is_error()) {
      FX_LOG_KV(ERROR, "Failed to get resolution context.",
                FX_KV("error", zx_status_get_string(resolution_context.value().error_value())));
      completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kInternal);
      return;
    }

    auto resolver = component::Connect<fuchsia_component_resolution::Resolver>(
        "/svc/fuchsia.component.resolution.Resolver-hermetic");
    if (resolver.is_error()) {
      FX_LOG_KV(ERROR, "Failed to connect to resolver protocol.");
      completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kInternal);
      return;
    }

    fidl::Arena arena;
    auto result = fidl::WireCall(*resolver)->ResolveWithContext(
        fidl::StringView(arena, relative_path), *resolution_context.value().value()->context.get());
    if (!result.ok() || result.value().is_error()) {
      FX_LOG_KV(ERROR, "Failed to resolve.");
      completer.ReplyError(fuchsia_component_resolution::wire::ResolverError::kInternal);
      return;
    }

    completer.ReplySuccess(result->value()->component);
  }

  static zx::result<zx::vmo> ReadFileToVmo(std::string_view path, zx_handle_t dir) {
    auto file_ep = fidl::CreateEndpoints<fuchsia_io::File>();
    if (file_ep.is_error()) {
      FX_LOG_KV(ERROR, "Failed to create file endpoints");
      return zx::error(ZX_ERR_INTERNAL);
    }

    zx_status_t status = fdio_open3_at(dir, std::string(path).data(),
                                       static_cast<uint64_t>(fuchsia_io::wire::kPermReadable),
                                       file_ep->server.channel().release());
    if (status != ZX_OK) {
      FX_LOG_KV(ERROR, "Failed to open file.", FX_KV("file", std::string(path).c_str()));
      return zx::error(ZX_ERR_IO);
    }

    fidl::WireResult result =
        fidl::WireCall(file_ep->client)->GetBackingMemory(fuchsia_io::wire::VmoFlags::kRead);
    if (!result.ok()) {
      FX_LOG_KV(DEBUG, "Failed to read file.", FX_KV("file", std::string(path).c_str()));
      return zx::error(ZX_ERR_NOT_FOUND);
    }

    auto& response = result.value();
    if (response.is_error()) {
      FX_LOG_KV(ERROR, "Failed to read file.", FX_KV("file", std::string(path).c_str()));
      return zx::error(ZX_ERR_IO);
    }

    return zx::ok(std::move(response.value()->vmo));
  }

  fidl::ClientEnd<fuchsia_io::Directory> boot_dir_;
  fidl::ClientEnd<fuchsia_io::Directory> test_pkg_dir_;
};

zx::result<std::list<ClientListEntry>> MakeClientList(
    fidl::UnownedClientEnd<fuchsia_io::Directory> boot_drivers_dir,
    fidl::UnownedClientEnd<fuchsia_io::Directory> test_pkg_dir,
    const std::optional<fuchsia_component_resolution::Context>& test_resolution_context) {
  std::list<ClientListEntry> client_list;

  zx::result cloned_boot_drivers_dir = component::Clone(boot_drivers_dir);
  if (cloned_boot_drivers_dir.is_error()) {
    FX_LOG_KV(ERROR, "Unable to clone dir");
    return zx::error(ZX_ERR_IO);
  }

  client_list.emplace_back(ClientListEntry{
      *std::move(cloned_boot_drivers_dir),
      "fuchsia-boot:///",
      "dtr",
  });

  if (test_pkg_dir.is_valid()) {
    zx::result cloned_test_pkg_dir = component::Clone(test_pkg_dir);
    if (cloned_test_pkg_dir.is_error()) {
      FX_LOG_KV(ERROR, "Unable to clone dir");
      return zx::error(ZX_ERR_IO);
    }

    // Add the test package itself.
    client_list.emplace_back(ClientListEntry{
        *std::move(cloned_test_pkg_dir),
        "dtr-test-pkg://fuchsia.com/",
        "",
    });

    // Need to clone again to use in fdio_fd_create.
    cloned_test_pkg_dir = component::Clone(test_pkg_dir);
    if (cloned_test_pkg_dir.is_error()) {
      FX_LOG_KV(ERROR, "Unable to clone dir");
      return zx::error(ZX_ERR_IO);
    }
    fbl::unique_fd dir_fd;
    zx_status_t status =
        fdio_fd_create(cloned_test_pkg_dir->TakeHandle().release(), dir_fd.reset_and_get_address());
    if (status != ZX_OK) {
      FX_LOG_KV(ERROR, "Failed to turn dir into fd");
      return zx::error(ZX_ERR_IO);
    }

    if (files::IsFileAt(dir_fd.get(), "meta/fuchsia.pkg/subpackages")) {
      // Read off the subpackages that exist in the test package.
      std::string result;
      files::ReadFileToStringAt(dir_fd.get(), "meta/fuchsia.pkg/subpackages", &result);
      rapidjson::Document subpackages_doc;
      subpackages_doc.Parse(result.c_str());
      auto& subpackages = subpackages_doc["subpackages"];
      std::vector<std::string> subpackage_names;
      subpackage_names.reserve(subpackages.MemberCount());
      for (rapidjson::Value::ConstMemberIterator itr = subpackages.MemberBegin();
           itr != subpackages.MemberEnd(); ++itr) {
        subpackage_names.push_back(itr->name.GetString());
      }

      if (!subpackage_names.empty()) {
        // Resolve the subpackage using the context.
        auto resolver = component::Connect<fuchsia_pkg::PackageResolver>(
            "/svc/fuchsia.pkg.PackageResolver-hermetic");
        if (resolver.is_error()) {
          FX_LOG_KV(ERROR, "Failed to connect to resolver protocol.",
                    FX_KV("error", zx_status_get_string(resolver.error_value())));
          return resolver.take_error();
        }
        if (!test_resolution_context.has_value()) {
          FX_LOG_KV(
              WARNING,
              "Subpackages exist in this package but a resolution context was not provided with the test_component. Skipping.");
        } else {
          fidl::Arena arena;
          fuchsia_pkg::wire::ResolutionContext converted_context(
              {.bytes = fidl::ToWire(arena, test_resolution_context->bytes())});

          // Add the subpackages of the test package into the list.
          for (auto& subpackage_name : subpackage_names) {
            auto [client, server] = fidl::Endpoints<fuchsia_io::Directory>::Create();
            auto resolve_result = fidl::WireCall(*resolver)->ResolveWithContext(
                fidl::StringView(arena, subpackage_name), converted_context, std::move(server));
            if (!resolve_result.ok() || resolve_result->is_error()) {
              FX_LOG_KV(ERROR, "Failed to resolve_with_context in the test package.",
                        FX_KV("error", resolve_result.FormatDescription().c_str()));
              return zx::error(ZX_ERR_INTERNAL);
            }

            client_list.emplace_back(ClientListEntry{
                std::move(client),
                "dtr-test-pkg://fuchsia.com/",
                subpackage_name,
            });
          }
        }
      }
    }
  }

  return zx::ok(std::move(client_list));
}

zx::result<BootAndBaseConfigResult> ConstructBootAndBaseConfig(
    std::list<ClientListEntry> client_list,
    const std::unordered_set<std::string>& boot_driver_components) {
  std::unordered_set<std::string> inserted;
  std::vector<std::string> boot_drivers;
  std::vector<std::string> base_drivers;

  for (auto& [dir, url_prefix, pkg_name] : client_list) {
    // Check each manifest to see if it uses the driver runner.
    fbl::unique_fd dir_fd;
    zx_status_t status = fdio_fd_create(dir.TakeHandle().release(), dir_fd.reset_and_get_address());
    if (status != ZX_OK) {
      FX_LOG_KV(ERROR, "Failed to turn dir into fd");
      return zx::error(ZX_ERR_IO);
    }

    std::vector<std::string> manifests;
    if (!files::ReadDirContentsAt(dir_fd.get(), "meta", &manifests)) {
      FX_LOG_KV(WARNING, "Unable to read dir contents.", FX_KV("url_prefix", url_prefix),
                FX_KV("pkg_name", pkg_name));
      continue;
    }

    for (const auto& manifest : manifests) {
      std::string manifest_path = "meta/" + manifest;
      if (!files::IsFileAt(dir_fd.get(), manifest_path) ||
          !cpp20::ends_with(std::string_view(manifest), ".cm")) {
        continue;
      }
      std::vector<uint8_t> manifest_bytes;
      if (!files::ReadFileToVectorAt(dir_fd.get(), manifest_path, &manifest_bytes)) {
        FX_LOG_KV(ERROR, "Unable to read file contents for", FX_KV("manifest", manifest_path));
        return zx::error(ZX_ERR_IO);
      }
      fit::result component = fidl::Unpersist<fuchsia_component_decl::Component>(manifest_bytes);
      if (component.is_error()) {
        FX_LOG_KV(ERROR, "Unable to unpersist component manifest",
                  FX_KV("manifest", manifest_path));
        return zx::error(ZX_ERR_IO);
      }
      if (!component->program() || !component->program()->runner() ||
          *component->program()->runner() != "driver") {
        continue;
      }

      // Construct the url entry from the pieces provided in the list entry.
      std::string entry = std::format("{}{}#meta/{}", url_prefix, pkg_name, manifest);

      // Protect against duplicate drivers. Only add the driver if it is unique.
      if (inserted.insert(std::format("{}", manifest)).second) {
        // Add to corresponding list.
        if (entry.starts_with("fuchsia-boot:///") ||
            boot_driver_components.find(manifest) != boot_driver_components.end()) {
          boot_drivers.push_back(entry);
        } else {
          base_drivers.push_back(entry);
        }
      }
    }
  }

  return zx::ok(BootAndBaseConfigResult{
      .boot_drivers = std::move(boot_drivers),
      .base_drivers = std::move(base_drivers),
  });
}

zx::result<BootAndBaseConfigResult> SetupLists(
    fidl::UnownedClientEnd<fuchsia_io::Directory> boot_dir,
    fidl::UnownedClientEnd<fuchsia_io::Directory> test_pkg_dir,
    const std::optional<fuchsia_component_resolution::Context>& test_resolution_context,
    const std::unordered_set<std::string>& boot_driver_components_set) {
  auto client_list = MakeClientList(boot_dir, test_pkg_dir, test_resolution_context);

  if (client_list.is_error()) {
    return client_list.take_error();
  }

  return ConstructBootAndBaseConfig(*std::move(client_list), boot_driver_components_set);
}

}  // namespace

int main() {
  async::Loop loop(&kAsyncLoopConfigAttachToCurrentThread);

  auto internal_client = component::Connect<fuchsia_driver_test::Internal>();
  if (internal_client.is_error()) {
    FX_LOG_KV(ERROR, "Failed to connect to internal protocol.");
    return internal_client.status_value();
  }

  fidl::ClientEnd<fuchsia_io::Directory> boot_dir;
  auto boot_result = fidl::WireCall(*internal_client)->GetBootDirectory();
  if (!boot_result.ok() || boot_result->is_error() || !boot_result->value()->boot_dir.is_valid()) {
    zx::result self_pkg = OpenPkgDir();
    if (self_pkg.is_error()) {
      return self_pkg.status_value();
    }
    boot_dir = std::move(self_pkg.value());
  } else {
    boot_dir = std::move(boot_result->value()->boot_dir);
  }

  fidl::ClientEnd<fuchsia_io::Directory> test_pkg_dir;
  std::optional<fuchsia_component_resolution::Context> test_resolution_context;
  auto test_pkg_result = fidl::WireCall(*internal_client)->GetTestPackage();
  if (test_pkg_result.ok() && test_pkg_result->is_ok() &&
      test_pkg_result->value()->test_pkg_dir.is_valid()) {
    test_pkg_dir = std::move(test_pkg_result->value()->test_pkg_dir);

    auto test_res_context_result = fidl::WireCall(*internal_client)->GetTestResolutionContext();
    if (test_res_context_result.ok() && test_res_context_result->is_ok() &&
        test_res_context_result->value()->context) {
      test_resolution_context.emplace(
          fidl::ToNatural(*test_res_context_result->value()->context.get()));
    }
  }

  std::unordered_set<std::string> boot_driver_components_set;
  auto boot_overrides_result = fidl::WireCall(*internal_client)->GetBootDriverOverrides();
  if (boot_overrides_result.ok() && boot_overrides_result->is_ok() &&
      !boot_overrides_result->value()->boot_overrides.empty()) {
    for (auto override : boot_overrides_result->value()->boot_overrides) {
      boot_driver_components_set.emplace(override.get());
    }
  }

  // Only index pkg if only one of boot or pkg was overridden.
  zx::result<BootAndBaseConfigResult> list_setup =
      SetupLists(boot_dir, test_pkg_dir, test_resolution_context, boot_driver_components_set);
  if (list_setup.is_error()) {
    return list_setup.status_value();
  }

  component::OutgoingDirectory outgoing(loop.dispatcher());
  zx::result<> serve_result = outgoing.ServeFromStartupInfo();
  if (serve_result.is_error()) {
    return serve_result.status_value();
  }

  // Server up driver lists.
  zx::result<> add_protocol_result = outgoing.AddProtocol<fuchsia_driver_test::DriverLists>(
      std::make_unique<DriverLists>(std::move(list_setup.value())));

  add_protocol_result = outgoing.AddProtocol<fuchsia_component_resolution::Resolver>(
      std::make_unique<FakeComponentResolver>(std::move(boot_dir), std::move(test_pkg_dir)));
  if (add_protocol_result.is_error()) {
    return add_protocol_result.status_value();
  }

  loop.Run();
  return 0;
}