#pragma once

#include <cstdint>
#include <map>
#include <optional>
#include <string>
#include <utility>

#include <sdbus-c++/sdbus-c++.h>

#include "absl/strings/string_view.h"
#include "absl/synchronization/mutex.h"
#include "internal/platform/implementation/linux/generated/dbus/bluez/agent_server.h"
#include "internal/platform/implementation/linux/generated/dbus/bluez/agentmanager_client.h"
#include "internal/platform/implementation/linux/bluez.h"
#include "internal/platform/logging.h"

namespace nearby::linux {

class Agent final
    : public sdbus::AdaptorInterfaces<org::bluez::Agent1_adaptor> {
 public:
  Agent(const Agent&) = delete;
  Agent(Agent&&) = delete;
  Agent& operator=(const Agent&) = delete;
  Agent& operator=(Agent&&) = delete;

  Agent(sdbus::IConnection& system_bus, sdbus::ObjectPath path)
      : AdaptorInterfaces(system_bus, std::move(path)) {
    registerAdaptor();
    LOG(INFO) << "Created new Agent at path: " << getObject().getObjectPath();
  }

  ~Agent() { unregisterAdaptor(); }

 private:
  void Release() override;

  std::string RequestPinCode(const sdbus::ObjectPath& device) override;
  void DisplayPinCode(const sdbus::ObjectPath& device,
                      const std::string& pincode) override;

  uint32_t RequestPasskey(const sdbus::ObjectPath& device) override;
  void DisplayPasskey(const sdbus::ObjectPath& device, const uint32_t& passkey,
                      const uint16_t& entered) override;

  void RequestConfirmation(const sdbus::ObjectPath& device,
                           const uint32_t& passkey) override;

  void RequestAuthorization(const sdbus::ObjectPath& device) override;

  void AuthorizeService(const sdbus::ObjectPath& device,
                        const std::string& uuid) override;

  void Cancel() override;
};

class AgentManager final
    : public sdbus::ProxyInterfaces<org::bluez::AgentManager1_proxy> {
 public:
  AgentManager(const AgentManager&) = delete;
  AgentManager(AgentManager&&) = delete;
  AgentManager& operator=(const AgentManager&) = delete;
  AgentManager& operator=(AgentManager&&) = delete;

  explicit AgentManager(sdbus::IConnection& system_bus)
      : ProxyInterfaces(system_bus, sdbus::ServiceName(bluez::SERVICE_DEST),
        sdbus::ObjectPath("/org/bluez")) {
    registerProxy();
  }

  ~AgentManager() { unregisterProxy(); }

  bool Register(std::optional<absl::string_view> capability,
                const sdbus::ObjectPath& agent_object_path);

  bool AgentRegistered(absl::string_view agent_object_path);

 private:
  absl::Mutex registered_agents_mutex_;
  std::map<std::string, std::shared_ptr<Agent>> registered_agents_
      ABSL_GUARDED_BY(registered_agents_mutex_);
};

}  // namespace nearby::linux