// Copyright 2015 The Chromium 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 "ash/mus/window_manager_application.h"

#include <utility>

#include "ash/common/material_design/material_design_controller.h"
#include "ash/common/mojo_interface_factory.h"
#include "ash/common/wm_shell.h"
#include "ash/mus/accelerators/accelerator_registrar_impl.h"
#include "ash/mus/native_widget_factory_mus.h"
#include "ash/mus/shelf_delegate_mus.h"
#include "ash/mus/wallpaper_delegate_mus.h"
#include "ash/mus/window_manager.h"
#include "base/bind.h"
#include "base/memory/ptr_util.h"
#include "services/shell/public/cpp/connection.h"
#include "services/shell/public/cpp/connector.h"
#include "services/tracing/public/cpp/provider.h"
#include "services/ui/common/event_matcher_util.h"
#include "services/ui/public/cpp/gpu_service.h"
#include "services/ui/public/cpp/window.h"
#include "services/ui/public/cpp/window_tree_client.h"
#include "ui/aura/env.h"
#include "ui/events/event.h"
#include "ui/message_center/message_center.h"
#include "ui/views/mus/aura_init.h"
#include "ui/views/mus/surface_context_factory.h"

#if defined(OS_CHROMEOS)
#include "ash/common/system/chromeos/power/power_status.h"
#include "chromeos/audio/cras_audio_handler.h"
#include "chromeos/dbus/dbus_thread_manager.h"
#include "chromeos/network/network_handler.h"
#include "chromeos/system/fake_statistics_provider.h"
#include "device/bluetooth/dbus/bluez_dbus_manager.h"  // nogncheck
#include "ui/chromeos/network/network_connect.h"
#endif

namespace ash {
namespace mus {

#if defined(OS_CHROMEOS)
// TODO(mash): Replace ui::NetworkConnect::Delegate with a mojo interface on a
// NetworkConfig service. http://crbug.com/644355
class WindowManagerApplication::StubNetworkConnectDelegate
    : public ui::NetworkConnect::Delegate {
 public:
  StubNetworkConnectDelegate() {}
  ~StubNetworkConnectDelegate() override {}

  void ShowNetworkConfigure(const std::string& network_id) override {}
  void ShowNetworkSettingsForGuid(const std::string& network_id) override {}
  bool ShowEnrollNetwork(const std::string& network_id) override {
    return false;
  }
  void ShowMobileSimDialog() override {}
  void ShowMobileSetupDialog(const std::string& service_path) override {}

 private:
  DISALLOW_COPY_AND_ASSIGN(StubNetworkConnectDelegate);
};
#endif  // OS_CHROMEOS

WindowManagerApplication::WindowManagerApplication()
    : screenlock_state_listener_binding_(this) {}

WindowManagerApplication::~WindowManagerApplication() {
  // AcceleratorRegistrarImpl removes an observer in its destructor. Destroy
  // it early on.
  std::set<AcceleratorRegistrarImpl*> accelerator_registrars(
      accelerator_registrars_);
  for (AcceleratorRegistrarImpl* registrar : accelerator_registrars)
    registrar->Destroy();

  // Destroy the WindowManager while still valid. This way we ensure
  // OnWillDestroyRootWindowController() is called (if it hasn't been already).
  window_manager_.reset();

  if (blocking_pool_) {
    // Like BrowserThreadImpl, the goal is to make it impossible for ash to
    // 'infinite loop' during shutdown, but to reasonably expect that all
    // BLOCKING_SHUTDOWN tasks queued during shutdown get run. There's nothing
    // particularly scientific about the number chosen.
    const int kMaxNewShutdownBlockingTasks = 1000;
    blocking_pool_->Shutdown(kMaxNewShutdownBlockingTasks);
  }

  gpu_service_.reset();
#if defined(OS_CHROMEOS)
  statistics_provider_.reset();
#endif
  ShutdownComponents();
}

void WindowManagerApplication::OnAcceleratorRegistrarDestroyed(
    AcceleratorRegistrarImpl* registrar) {
  accelerator_registrars_.erase(registrar);
}

void WindowManagerApplication::InitWindowManager(
    std::unique_ptr<ui::WindowTreeClient> window_tree_client,
    const scoped_refptr<base::SequencedWorkerPool>& blocking_pool) {
  InitializeComponents();
#if defined(OS_CHROMEOS)
  // TODO(jamescook): Refactor StatisticsProvider so we can get just the data
  // we need in ash. Right now StatisticsProviderImpl launches the crossystem
  // binary to get system data, which we don't want to do twice on startup.
  statistics_provider_.reset(
      new chromeos::system::ScopedFakeStatisticsProvider());
  statistics_provider_->SetMachineStatistic("initial_locale", "en-US");
  statistics_provider_->SetMachineStatistic("keyboard_layout", "");
#endif
  window_manager_->Init(std::move(window_tree_client), blocking_pool);
  native_widget_factory_mus_ =
      base::MakeUnique<NativeWidgetFactoryMus>(window_manager_.get());
}

void WindowManagerApplication::InitializeComponents() {
  message_center::MessageCenter::Initialize();
#if defined(OS_CHROMEOS)
  // Must occur after mojo::ApplicationRunner has initialized AtExitManager, but
  // before WindowManager::Init().
  chromeos::DBusThreadManager::Initialize(
      chromeos::DBusThreadManager::PROCESS_ASH);

  // See ChromeBrowserMainPartsChromeos for ordering details.
  bluez::BluezDBusManager::Initialize(
      chromeos::DBusThreadManager::Get()->GetSystemBus(),
      chromeos::DBusThreadManager::Get()->IsUsingFakes());
  chromeos::NetworkHandler::Initialize();
  network_connect_delegate_.reset(new StubNetworkConnectDelegate());
  ui::NetworkConnect::Initialize(network_connect_delegate_.get());
  // TODO(jamescook): Initialize real audio handler.
  chromeos::CrasAudioHandler::InitializeForTesting();
  PowerStatus::Initialize();
#endif
}

void WindowManagerApplication::ShutdownComponents() {
#if defined(OS_CHROMEOS)
  PowerStatus::Shutdown();
  chromeos::CrasAudioHandler::Shutdown();
  ui::NetworkConnect::Shutdown();
  network_connect_delegate_.reset();
  chromeos::NetworkHandler::Shutdown();
  bluez::BluezDBusManager::Shutdown();
  chromeos::DBusThreadManager::Shutdown();
#endif
  message_center::MessageCenter::Shutdown();
}

void WindowManagerApplication::OnStart(const shell::Identity& identity) {
  aura_init_.reset(new views::AuraInit(connector(), "ash_mus_resources.pak",
                                       "ash_mus_resources_200.pak"));
  gpu_service_ = ui::GpuService::Create(connector());
  compositor_context_factory_.reset(
      new views::SurfaceContextFactory(gpu_service_.get()));
  aura::Env::GetInstance()->set_context_factory(
      compositor_context_factory_.get());
  window_manager_.reset(new WindowManager(connector()));

  MaterialDesignController::Initialize();

  tracing_.Initialize(connector(), identity.name());

  std::unique_ptr<ui::WindowTreeClient> window_tree_client =
      base::MakeUnique<ui::WindowTreeClient>(window_manager_.get(),
                                             window_manager_.get());
  window_tree_client->ConnectAsWindowManager(connector());

  const size_t kMaxNumberThreads = 3u;  // Matches that of content.
  const char kThreadNamePrefix[] = "MashBlocking";
  blocking_pool_ = new base::SequencedWorkerPool(
      kMaxNumberThreads, kThreadNamePrefix, base::TaskPriority::USER_VISIBLE);
  InitWindowManager(std::move(window_tree_client), blocking_pool_);
}

bool WindowManagerApplication::OnConnect(const shell::Identity& remote_identity,
                                         shell::InterfaceRegistry* registry) {
  // Register services used in both classic ash and mash.
  mojo_interface_factory::RegisterInterfaces(
      registry, base::ThreadTaskRunnerHandle::Get());

  registry->AddInterface<mojom::ShelfController>(this);
  registry->AddInterface<mojom::WallpaperController>(this);
  registry->AddInterface<ui::mojom::AcceleratorRegistrar>(this);
  if (remote_identity.name() == "service:mash_session") {
    connector()->ConnectToInterface(remote_identity, &session_);
    session_->AddScreenlockStateListener(
        screenlock_state_listener_binding_.CreateInterfacePtrAndBind());
  }
  return true;
}

void WindowManagerApplication::Create(const shell::Identity& remote_identity,
                                      mojom::ShelfControllerRequest request) {
  mojom::ShelfController* shelf_controller =
      static_cast<ShelfDelegateMus*>(WmShell::Get()->shelf_delegate());
  DCHECK(shelf_controller);
  shelf_controller_bindings_.AddBinding(shelf_controller, std::move(request));
}

void WindowManagerApplication::Create(
    const ::shell::Identity& remote_identity,
    mojom::WallpaperControllerRequest request) {
  mojom::WallpaperController* wallpaper_controller =
      static_cast<WallpaperDelegateMus*>(WmShell::Get()->wallpaper_delegate());
  DCHECK(wallpaper_controller);
  wallpaper_controller_bindings_.AddBinding(wallpaper_controller,
                                            std::move(request));
}

void WindowManagerApplication::Create(
    const shell::Identity& remote_identity,
    ui::mojom::AcceleratorRegistrarRequest request) {
  if (!window_manager_->window_manager_client())
    return;  // Can happen during shutdown.

  uint16_t accelerator_namespace_id;
  if (!window_manager_->GetNextAcceleratorNamespaceId(
          &accelerator_namespace_id)) {
    DVLOG(1) << "Max number of accelerators registered, ignoring request.";
    // All ids are used. Normally shouldn't happen, so we close the connection.
    return;
  }
  accelerator_registrars_.insert(new AcceleratorRegistrarImpl(
      window_manager_.get(), accelerator_namespace_id, std::move(request),
      base::Bind(&WindowManagerApplication::OnAcceleratorRegistrarDestroyed,
                 base::Unretained(this))));
}

void WindowManagerApplication::ScreenlockStateChanged(bool locked) {
  window_manager_->SetScreenLocked(locked);
}

}  // namespace mus
}  // namespace ash