// Copyright 2017 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.

#ifndef PERIDOT_LIB_TESTING_ENTITY_RESOLVER_FAKE_H_
#define PERIDOT_LIB_TESTING_ENTITY_RESOLVER_FAKE_H_

#include <map>
#include <memory>
#include <string>

#include <fuchsia/modular/cpp/fidl.h>
#include <lib/fidl/cpp/binding_set.h>
#include <lib/fidl/cpp/interface_request.h>
#include <lib/fidl/cpp/string.h>
#include <src/lib/fxl/macros.h>

namespace modular {

class EntityResolverFake : public fuchsia::modular::EntityResolver {
 public:
  EntityResolverFake();
  ~EntityResolverFake() override;

  void Connect(fidl::InterfaceRequest<fuchsia::modular::EntityResolver> request);

  // Returns an fuchsia::modular::Entity reference that will resolve to an
  // fuchsia::modular::Entity. |types_and_data| is a map of data type to data
  // bytes.
  fidl::StringPtr AddEntity(std::map<std::string, std::string> types_and_data);

 private:
  class EntityImpl;

  void ResolveEntity(std::string entity_reference,
                     fidl::InterfaceRequest<fuchsia::modular::Entity> entity_request) override;

  int next_entity_id_{0};
  std::map<std::string, std::unique_ptr<EntityImpl>> entities_;
  fidl::BindingSet<fuchsia::modular::EntityResolver> bindings_;
};

}  // namespace modular

#endif  // PERIDOT_LIB_TESTING_ENTITY_RESOLVER_FAKE_H_
