// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/ash/nearby/nearby_dependencies_provider.h"

#include "ash/constants/ash_features.h"
#include "ash/public/cpp/network_config_service.h"
#include "base/command_line.h"
#include "base/feature_list.h"
#include "base/functional/bind.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/singleton.h"
#include "chrome/browser/ash/nearby/bluetooth_adapter_manager.h"
#include "chrome/browser/ash/nearby/nearby_dependencies_provider_factory.h"
#include "chrome/browser/ash/nearby/presence/credential_storage/credential_storage_initializer.h"
#include "chrome/browser/nearby_sharing/common/nearby_share_features.h"
#include "chrome/browser/nearby_sharing/common/nearby_share_switches.h"
#include "chrome/browser/nearby_sharing/firewall_hole/nearby_connections_firewall_hole_factory.h"
#include "chrome/browser/nearby_sharing/mdns/nearby_connections_mdns_manager.h"
#include "chrome/browser/nearby_sharing/sharing_mojo_service.h"
#include "chrome/browser/nearby_sharing/tachyon_ice_config_fetcher.h"
#include "chrome/browser/nearby_sharing/tcp_socket/nearby_connections_tcp_socket_factory.h"
#include "chrome/browser/nearby_sharing/webrtc_signaling_messenger.h"
#include "chrome/browser/profiles/profile.h"
#include "chromeos/ash/services/nearby/public/mojom/firewall_hole.mojom.h"
#include "chromeos/ash/services/nearby/public/mojom/mdns.mojom.h"
#include "chromeos/ash/services/nearby/public/mojom/nearby_connections.mojom.h"
#include "chromeos/ash/services/nearby/public/mojom/sharing.mojom.h"
#include "chromeos/ash/services/nearby/public/mojom/tcp_socket_factory.mojom.h"
#include "chromeos/services/network_config/public/mojom/cros_network_config.mojom.h"
#include "components/cross_device/nearby/nearby_features.h"
#include "components/keyed_service/content/browser_context_keyed_service_shutdown_notifier_factory.h"
#include "components/keyed_service/core/keyed_service_shutdown_notifier.h"
#include "content/public/browser/network_service_instance.h"
#include "content/public/browser/storage_partition.h"
#include "device/bluetooth/bluetooth_adapter_factory.h"
#include "mojo/public/cpp/bindings/self_owned_receiver.h"
#include "net/base/network_isolation_key.h"
#include "services/network/public/mojom/p2p_trusted.mojom.h"

namespace ash {
namespace nearby {
namespace {

template <typename T>
struct MojoPipe {
  mojo::PendingRemote<T> remote;
  mojo::PendingReceiver<T> receiver{remote.InitWithNewPipeAndPassReceiver()};
};

class P2PTrustedSocketManagerClientImpl
    : public network::mojom::P2PTrustedSocketManagerClient {
 public:
  explicit P2PTrustedSocketManagerClientImpl(
      mojo::PendingRemote<network::mojom::P2PTrustedSocketManager>
          socket_manager)
      : socket_manager_(std::move(socket_manager)) {}
  ~P2PTrustedSocketManagerClientImpl() override = default;

  // network::mojom::P2PTrustedSocketManagerClient:
  void InvalidSocketPortRangeRequested() override { NOTIMPLEMENTED(); }
  void DumpPacket(const std::vector<uint8_t>& packet_header,
                  uint64_t packet_length,
                  bool incoming) override {
    NOTIMPLEMENTED();
  }

 private:
  mojo::Remote<network::mojom::P2PTrustedSocketManager> socket_manager_;
};

// Allows observers to be notified when NearbyDependenciesProvider is shut down.
class NearbyDependenciesProviderShutdownNotifierFactory
    : public BrowserContextKeyedServiceShutdownNotifierFactory {
 public:
  static NearbyDependenciesProviderShutdownNotifierFactory* GetInstance() {
    return base::Singleton<
        NearbyDependenciesProviderShutdownNotifierFactory>::get();
  }

  NearbyDependenciesProviderShutdownNotifierFactory(
      const NearbyDependenciesProviderShutdownNotifierFactory&) = delete;
  NearbyDependenciesProviderShutdownNotifierFactory& operator=(
      const NearbyDependenciesProviderShutdownNotifierFactory&) = delete;

 private:
  friend struct base::DefaultSingletonTraits<
      NearbyDependenciesProviderShutdownNotifierFactory>;

  NearbyDependenciesProviderShutdownNotifierFactory()
      : BrowserContextKeyedServiceShutdownNotifierFactory(
            "NearbyDependenciesProvider") {
    DependsOn(NearbyDependenciesProviderFactory::GetInstance());
  }
  ~NearbyDependenciesProviderShutdownNotifierFactory() override = default;
};

class MdnsResponderFactory : public ::sharing::mojom::MdnsResponderFactory {
 public:
  explicit MdnsResponderFactory(Profile* profile) : profile_(profile) {
    // Subscribe to be notified when NearbyDependenciesProvider shuts down.
    // NearbyDependenciesProvider is a KeyedService bound to |profile_|, so the
    // destruction of NearbyDependenciesProvider means that |profile_| is
    // invalid. This lets us return early from CreateMdnsResponder() to avoid
    // the risk of using |profile_| after it has been destroyed. Using
    // base::Unretained() is safe here because the MdnsResponderFactory is
    // guaranteed to outlive |shutdown_subscription_|.
    shutdown_subscription_ =
        NearbyDependenciesProviderShutdownNotifierFactory::GetInstance()
            ->Get(profile_)
            ->Subscribe(base::BindRepeating(&MdnsResponderFactory::Shutdown,
                                            base::Unretained(this)));
  }

  void CreateMdnsResponder(mojo::PendingReceiver<network::mojom::MdnsResponder>
                               responder_receiver) override {
    if (is_shutdown_) {
      return;
    }

    auto* partition = profile_->GetDefaultStoragePartition();
    if (!partition) {
      LOG(ERROR) << "MdnsResponderFactory::" << __func__
                 << ": GetDefaultStoragePartition(profile) failed.";
      // When |responder_receiver| goes out of scope the pipe will disconnect.
      return;
    }

    auto* network_context = partition->GetNetworkContext();
    if (!network_context) {
      LOG(ERROR) << "MdnsResponderFactory::" << __func__
                 << ": GetNetworkContext() failed.";
      // When |responder_receiver| goes out of scope the pipe will disconnect.
      return;
    }

    network_context->CreateMdnsResponder(std::move(responder_receiver));
  }

 private:
  void Shutdown() { is_shutdown_ = true; }

  bool is_shutdown_ = false;
  raw_ptr<Profile, LeakedDanglingUntriaged> profile_;
  base::CallbackListSubscription shutdown_subscription_;
};

}  // namespace

NearbyDependenciesProvider::NearbyDependenciesProvider(
    Profile* profile,
    signin::IdentityManager* identity_manager)
    : profile_(profile), identity_manager_(identity_manager) {
  DCHECK(profile_);
  bluetooth_manager_ = std::make_unique<BluetoothAdapterManager>();
}

NearbyDependenciesProvider::NearbyDependenciesProvider() = default;

NearbyDependenciesProvider::~NearbyDependenciesProvider() = default;

::sharing::mojom::NearbyDependenciesPtr
NearbyDependenciesProvider::GetDependencies() {
  if (shut_down_) {
    return nullptr;
  }

  auto dependencies = ::sharing::mojom::NearbyDependencies::New();

  if (device::BluetoothAdapterFactory::IsBluetoothSupported()) {
    dependencies->bluetooth_adapter = GetBluetoothAdapterPendingRemote();
  } else {
    dependencies->bluetooth_adapter = mojo::NullRemote();
  }

  // TOOD(b/317307931): Re-visit security considerations before enabling
  // this feature by default/ramping up via Finch.
  if (ash::features::IsNearbyPresenceEnabled()) {
    dependencies->nearby_presence_credential_storage =
        GetNearbyPresenceCredentialStoragePendingRemote();
  } else {
    dependencies->nearby_presence_credential_storage = mojo::NullRemote();
  }

  dependencies->webrtc_dependencies = GetWebRtcDependencies();
  dependencies->wifilan_dependencies = GetWifiLanDependencies();
  dependencies->wifidirect_dependencies = GetWifiDirectDependencies();

  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
  if (command_line->HasSwitch(switches::kNearbyShareVerboseLogging)) {
    dependencies->min_log_severity =
        ::nearby::api::LogMessage::Severity::kVerbose;
  }

  return dependencies;
}

void NearbyDependenciesProvider::PrepareForShutdown() {
  if (bluetooth_manager_) {
    bluetooth_manager_->Shutdown();
  }

  presence_credential_storage_initializer_.reset();
}

void NearbyDependenciesProvider::Shutdown() {
  shut_down_ = true;
}

mojo::PendingRemote<bluetooth::mojom::Adapter>
NearbyDependenciesProvider::GetBluetoothAdapterPendingRemote() {
  mojo::PendingReceiver<bluetooth::mojom::Adapter> pending_receiver;
  mojo::PendingRemote<bluetooth::mojom::Adapter> pending_remote =
      pending_receiver.InitWithNewPipeAndPassRemote();
  device::BluetoothAdapterFactory::Get()->GetAdapter(base::BindOnce(
      &BluetoothAdapterManager::Initialize, bluetooth_manager_->GetWeakPtr(),
      std::move(pending_receiver)));
  return pending_remote;
}

mojo::PendingRemote<presence::mojom::NearbyPresenceCredentialStorage>
NearbyDependenciesProvider::GetNearbyPresenceCredentialStoragePendingRemote() {
  mojo::PendingReceiver<presence::mojom::NearbyPresenceCredentialStorage>
      pending_receiver;
  mojo::PendingRemote<presence::mojom::NearbyPresenceCredentialStorage>
      pending_remote = pending_receiver.InitWithNewPipeAndPassRemote();

  presence_credential_storage_initializer_ =
      std::make_unique<presence::CredentialStorageInitializer>(
          std::move(pending_receiver), profile_);
  presence_credential_storage_initializer_->Initialize();

  return pending_remote;
}

::sharing::mojom::WebRtcDependenciesPtr
NearbyDependenciesProvider::GetWebRtcDependencies() {
  MojoPipe<network::mojom::P2PTrustedSocketManagerClient> socket_manager_client;
  MojoPipe<network::mojom::P2PTrustedSocketManager> trusted_socket_manager;
  MojoPipe<network::mojom::P2PSocketManager> socket_manager;

  mojo::MakeSelfOwnedReceiver(
      std::make_unique<P2PTrustedSocketManagerClientImpl>(
          std::move(trusted_socket_manager.remote)),
      std::move(socket_manager_client.receiver));

  // Create socket manager.
  GetNetworkContext()->CreateP2PSocketManager(
      net::NetworkAnonymizationKey::CreateTransient(),
      std::move(socket_manager_client.remote),
      std::move(trusted_socket_manager.receiver),
      std::move(socket_manager.receiver));

  MojoPipe<::sharing::mojom::MdnsResponderFactory> mdns_responder_factory_pipe;
  mojo::MakeSelfOwnedReceiver(std::make_unique<MdnsResponderFactory>(profile_),
                              std::move(mdns_responder_factory_pipe.receiver));

  // Create ice config fetcher.
  auto url_loader_factory = profile_->GetURLLoaderFactory();
  MojoPipe<::sharing::mojom::IceConfigFetcher> ice_config_fetcher;
  mojo::MakeSelfOwnedReceiver(std::make_unique<TachyonIceConfigFetcher>(
                                  identity_manager_, url_loader_factory),
                              std::move(ice_config_fetcher.receiver));

  MojoPipe<::sharing::mojom::WebRtcSignalingMessenger> messenger;
  mojo::MakeSelfOwnedReceiver(std::make_unique<WebRtcSignalingMessenger>(
                                  identity_manager_, url_loader_factory),
                              std::move(messenger.receiver));

  return ::sharing::mojom::WebRtcDependencies::New(
      std::move(socket_manager.remote),
      std::move(mdns_responder_factory_pipe.remote),
      std::move(ice_config_fetcher.remote), std::move(messenger.remote));
}

::sharing::mojom::WifiLanDependenciesPtr
NearbyDependenciesProvider::GetWifiLanDependencies() {
  MojoPipe<chromeos::network_config::mojom::CrosNetworkConfig>
      cros_network_config;
  ash::GetNetworkConfigService(std::move(cros_network_config.receiver));

  MojoPipe<::sharing::mojom::FirewallHoleFactory> firewall_hole_factory;
  mojo::MakeSelfOwnedReceiver(
      std::make_unique<NearbyConnectionsFirewallHoleFactory>(),
      std::move(firewall_hole_factory.receiver));

  MojoPipe<::sharing::mojom::TcpSocketFactory> tcp_socket_factory;
  mojo::MakeSelfOwnedReceiver(
      std::make_unique<NearbyConnectionsTcpSocketFactory>(
          base::BindRepeating(&NearbyDependenciesProvider::GetNetworkContext,
                              base::Unretained(this))),
      std::move(tcp_socket_factory.receiver));

  MojoPipe<::sharing::mojom::MdnsManager> mdns_manager;
  if (::features::IsNearbyMdnsEnabled()) {
    mojo::MakeSelfOwnedReceiver(
        std::make_unique<::nearby::sharing::NearbyConnectionsMdnsManager>(),
        std::move(mdns_manager.receiver));
  }

  return ::sharing::mojom::WifiLanDependencies::New(
      std::move(cros_network_config.remote),
      std::move(firewall_hole_factory.remote),
      std::move(tcp_socket_factory.remote),
      (::features::IsNearbyMdnsEnabled() ? std::move(mdns_manager.remote)
                                         : mojo::NullRemote()));
}

sharing::mojom::WifiDirectDependenciesPtr
NearbyDependenciesProvider::GetWifiDirectDependencies() {
  MojoPipe<sharing::mojom::FirewallHoleFactory> firewall_hole_factory;
  mojo::MakeSelfOwnedReceiver(
      std::make_unique<NearbyConnectionsFirewallHoleFactory>(),
      std::move(firewall_hole_factory.receiver));

  wifi_direct_manager_ = std::make_unique<wifi_direct::WifiDirectManager>();
  MojoPipe<wifi_direct::mojom::WifiDirectManager> manager;
  wifi_direct_manager_->BindPendingReceiver(std::move(manager.receiver));

  return sharing::mojom::WifiDirectDependencies::New(
      std::move(manager.remote), std::move(firewall_hole_factory.remote));
}

network::mojom::NetworkContext*
NearbyDependenciesProvider::GetNetworkContext() {
  return profile_->GetDefaultStoragePartition()->GetNetworkContext();
}

// static
void NearbyDependenciesProvider::EnsureFactoryBuilt() {
  NearbyDependenciesProviderShutdownNotifierFactory::GetInstance();
}

}  // namespace nearby
}  // namespace ash