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

#include "semantic_provider_impl.h"

#include <fidl/fuchsia.accessibility.semantics/cpp/fidl.h>
#include <fidl/fuchsia.ui.views/cpp/hlcpp_conversion.h>
#include <lib/async/default.h>

#include <algorithm>
#include <memory>

#include "base/fuchsia/fidl_event_handler.h"
#include "base/fuchsia/scoped_service_binding.h"
#include "base/fuchsia/test_component_context_for_process.h"
#include "base/functional/callback.h"
#include "base/run_loop.h"
#include "base/test/task_environment.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace ui {
namespace {

using fuchsia_accessibility_semantics::Node;

class AXFuchsiaSemanticProviderDelegate
    : public AXFuchsiaSemanticProvider::Delegate {
 public:
  AXFuchsiaSemanticProviderDelegate() = default;
  ~AXFuchsiaSemanticProviderDelegate() override = default;

  bool OnSemanticsManagerConnectionClosed(zx_status_t status) override {
    on_semantics_manager_connection_closed_called_ = true;
    return true;
  }

  bool OnAccessibilityAction(
      uint32_t node_id,
      fuchsia_accessibility_semantics::Action action) override {
    on_accessibility_action_called_ = true;
    on_accessibility_action_node_id_ = node_id;
    on_accessibility_action_action_ = std::move(action);
    return true;
  }

  void OnHitTest(fuchsia_math::PointF point,
                 HitTestCallback callback) override {
    on_hit_test_called_ = true;
    on_hit_test_point_ = std::move(point);
    std::move(callback).Run({});
  }

  void OnSemanticsEnabled(bool enabled) override {
    on_semantics_enabled_called_ = true;
  }

  bool on_semantics_manager_connection_closed_called_;
  bool on_accessibility_action_called_;
  uint32_t on_accessibility_action_node_id_ = 10000000;
  fuchsia_accessibility_semantics::Action on_accessibility_action_action_;
  bool on_hit_test_called_;
  fuchsia_math::PointF on_hit_test_point_;
  bool on_semantics_enabled_called_;
};

// Returns a semantic tree of the form:
// (0 (1 2 (3 4 (5))))
std::vector<Node> TreeNodes() {
  Node node_0;
  node_0.node_id(0u);
  node_0.child_ids({{1u, 2u}});

  Node node_1;
  node_1.node_id(1u);

  Node node_2;
  node_2.node_id(2u);
  node_2.child_ids({{3u, 4u}});

  Node node_3;
  node_3.node_id(3u);

  Node node_4;
  node_4.node_id(4u);
  node_4.child_ids({{5u}});

  Node node_5;
  node_5.node_id(5u);

  std::vector<Node> update;
  update.push_back(std::move(node_0));
  update.push_back(std::move(node_1));
  update.push_back(std::move(node_2));
  update.push_back(std::move(node_3));
  update.push_back(std::move(node_4));
  update.push_back(std::move(node_5));
  return update;
}

class AXFuchsiaSemanticProviderTest
    : public ::testing::Test,
      public fidl::Server<fuchsia_accessibility_semantics::SemanticsManager>,
      public fidl::Server<fuchsia_accessibility_semantics::SemanticTree> {
 public:
  AXFuchsiaSemanticProviderTest()
      : semantics_manager_bindings_(test_context_.additional_services(), this),
        semantic_listener_error_handler_(
            base::BindRepeating([](fidl::UnbindInfo info) { ADD_FAILURE(); })) {
  }
  ~AXFuchsiaSemanticProviderTest() override = default;
  AXFuchsiaSemanticProviderTest(const AXFuchsiaSemanticProviderTest&) = delete;
  AXFuchsiaSemanticProviderTest& operator=(
      const AXFuchsiaSemanticProviderTest&) = delete;
  void SetUp() override {
    fuchsia::ui::views::ViewRefControl view_ref_control;
    fuchsia::ui::views::ViewRef view_ref;
    auto status = zx::eventpair::create(
        /*options*/ 0u, &view_ref_control.reference, &view_ref.reference);
    CHECK_EQ(ZX_OK, status);
    view_ref.reference.replace(ZX_RIGHTS_BASIC, &view_ref.reference);

    delegate_ = std::make_unique<AXFuchsiaSemanticProviderDelegate>();

    semantic_provider_ = std::make_unique<AXFuchsiaSemanticProviderImpl>(
        fidl::HLCPPToNatural(std::move(view_ref)), delegate_.get());

    // Spin the loop to allow registration with the SemanticsManager to be
    // processed.
    base::RunLoop().RunUntilIdle();
  }

 protected:
  // fuchsia_accessibility_semantics::SemanticsManager implementation.
  void RegisterViewForSemantics(
      AXFuchsiaSemanticProviderTest::RegisterViewForSemanticsRequest& request,
      AXFuchsiaSemanticProviderTest::RegisterViewForSemanticsCompleter::Sync&
          completer) final {
    semantic_listener_.Bind(std::move(request.listener()),
                            async_get_default_dispatcher(),
                            &semantic_listener_error_handler_);
    semantic_tree_binding_.emplace(async_get_default_dispatcher(),
                                   std::move(request.semantic_tree_request()),
                                   this, fidl::kIgnoreBindingClosure);
    semantic_listener_->OnSemanticsModeChanged({{.updates_enabled = true}})
        .Then(
            [](fidl::Result<fuchsia_accessibility_semantics::SemanticListener::
                                OnSemanticsModeChanged>& result) {
              ASSERT_TRUE(result.is_ok());
            });
  }

  // fuchsia_accessibility_semantics::SemanticTree implementation.
  void UpdateSemanticNodes(
      AXFuchsiaSemanticProviderTest::UpdateSemanticNodesRequest& request,
      AXFuchsiaSemanticProviderTest::UpdateSemanticNodesCompleter::Sync&
          ignored_completer) final {
    num_update_semantic_nodes_called_++;
    node_updates_.push_back(std::move(request.nodes()));
  }
  void DeleteSemanticNodes(
      AXFuchsiaSemanticProviderTest::DeleteSemanticNodesRequest& request,
      AXFuchsiaSemanticProviderTest::DeleteSemanticNodesCompleter::Sync&
          ignored_completer) final {
    num_delete_semantic_nodes_called_++;
  }
  void CommitUpdates(
      AXFuchsiaSemanticProviderTest::CommitUpdatesCompleter::Sync& completer)
      final {
    completer.Reply();
  }
  void SendSemanticEvent(
      AXFuchsiaSemanticProviderTest::SendSemanticEventRequest& request,
      AXFuchsiaSemanticProviderTest::SendSemanticEventCompleter::Sync&
          completer) override {
    completer.Reply();
  }

  const std::vector<std::vector<fuchsia_accessibility_semantics::Node>>&
  node_updates() {
    return node_updates_;
  }

  // Required because of |test_context_|.
  base::test::SingleThreadTaskEnvironment task_environment_{
      base::test::SingleThreadTaskEnvironment::MainThreadType::IO};
  base::TestComponentContextForProcess test_context_;
  // Binding to fake Semantics Manager Fuchsia service, implemented by this test
  // class.
  base::ScopedNaturalServiceBinding<
      fuchsia_accessibility_semantics::SemanticsManager>
      semantics_manager_bindings_;

  uint32_t num_update_semantic_nodes_called_ = 0;
  uint32_t num_delete_semantic_nodes_called_ = 0;

  base::RepeatingClosure on_commit_;

  fidl::Client<fuchsia_accessibility_semantics::SemanticListener>
      semantic_listener_;
  base::FidlErrorEventHandler<fuchsia_accessibility_semantics::SemanticListener>
      semantic_listener_error_handler_;
  std::optional<
      fidl::ServerBinding<fuchsia_accessibility_semantics::SemanticTree>>
      semantic_tree_binding_;
  std::unique_ptr<AXFuchsiaSemanticProviderDelegate> delegate_;
  std::unique_ptr<AXFuchsiaSemanticProviderImpl> semantic_provider_;

  // Node updates batched per API call to UpdateSemanticNodes().
  std::vector<std::vector<fuchsia_accessibility_semantics::Node>> node_updates_;
};

TEST_F(AXFuchsiaSemanticProviderTest, HandlesOnSemanticsConnectionClosed) {
  ASSERT_TRUE(semantic_tree_binding_.has_value());
  semantic_tree_binding_->Close(ZX_ERR_PEER_CLOSED);

  // Spin the loop to allow the channel-close to be handled.
  base::RunLoop().RunUntilIdle();

  EXPECT_TRUE(delegate_->on_semantics_manager_connection_closed_called_);
}

TEST_F(AXFuchsiaSemanticProviderTest, HandlesOnAccessibilityAction) {
  bool action_handled = false;
  semantic_listener_
      ->OnAccessibilityActionRequested({{
          .node_id = 1u,
          .action = fuchsia_accessibility_semantics::Action::kDefault,
      }})
      .Then([&action_handled](
                fidl::Result<fuchsia_accessibility_semantics::SemanticListener::
                                 OnAccessibilityActionRequested>& result) {
        ASSERT_TRUE(result.is_ok());
        action_handled = result->handled();
      });

  // Spin the loop to handle the request, and receive the response.
  base::RunLoop().RunUntilIdle();

  EXPECT_TRUE(action_handled);
  EXPECT_TRUE(delegate_->on_accessibility_action_called_);
  EXPECT_EQ(delegate_->on_accessibility_action_node_id_, 1u);
  EXPECT_EQ(delegate_->on_accessibility_action_action_,
            fuchsia_accessibility_semantics::Action::kDefault);
}

TEST_F(AXFuchsiaSemanticProviderTest, HandlesOnHitTest) {
  semantic_provider_->SetPixelScale(2.f);

  // Note that the point is sent here and will be converted according to the
  // device scale used. Only then it gets sent to the handler, which receives
  // the value already with the proper scaling.
  semantic_listener_
      ->HitTest({{
          .local_point = {{.x = 4, .y = 6}},
      }})
      .Then([](fidl::Result<
                fuchsia_accessibility_semantics::SemanticListener::HitTest>&
                   result) { ASSERT_TRUE(result.is_ok()); });

  // Spin the loop to allow the call to be processed.
  base::RunLoop().RunUntilIdle();

  EXPECT_TRUE(delegate_->on_hit_test_called_);
  EXPECT_EQ(delegate_->on_hit_test_point_.x(), 8.0);
  EXPECT_EQ(delegate_->on_hit_test_point_.y(), 12.0);
}

// Verify that the AXFuchsiaSemanticProviderImpl constructor triggered the call
// chain RegisterViewForSemantics -> OnSemanticsModeChanged ->
// OnSemanticsEnabled.
TEST_F(AXFuchsiaSemanticProviderTest, HandlesOnSemanticsEnabled) {
  EXPECT_TRUE(delegate_->on_semantics_enabled_called_);
}

TEST_F(AXFuchsiaSemanticProviderTest, SendsRootOnly) {
  Node root;
  root.node_id(0u);
  EXPECT_TRUE(semantic_provider_->Update(std::move(root)));

  // Spin the loop to process the update call.
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(num_update_semantic_nodes_called_, 1u);
  EXPECT_FALSE(semantic_provider_->HasPendingUpdates());
}

TEST_F(AXFuchsiaSemanticProviderTest, SendsNodesFromRootToLeaves) {
  auto tree_nodes = TreeNodes();
  for (auto& node : tree_nodes) {
    EXPECT_TRUE(semantic_provider_->Update(std::move(node)));
  }

  // Spin the loop to process the queued update calls.
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(num_update_semantic_nodes_called_, 1u);
  EXPECT_FALSE(semantic_provider_->HasPendingUpdates());
}

TEST_F(AXFuchsiaSemanticProviderTest, SendsNodesFromLeavesToRoot) {
  auto nodes = TreeNodes();
  std::reverse(nodes.begin(), nodes.end());
  for (auto& node : nodes) {
    EXPECT_TRUE(semantic_provider_->Update(std::move(node)));
  }

  // Spin the loop to process the queued update calls.
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(num_update_semantic_nodes_called_, 1u);
  EXPECT_FALSE(semantic_provider_->HasPendingUpdates());
}

TEST_F(AXFuchsiaSemanticProviderTest,
       SendsNodesOnlyAfterParentNoLongerPointsToDeletedChild) {
  auto tree_nodes = TreeNodes();
  for (auto& node : tree_nodes) {
    EXPECT_TRUE(semantic_provider_->Update(std::move(node)));
  }

  // Spin the loop to process the queued update calls.
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(num_update_semantic_nodes_called_, 1u);
  EXPECT_FALSE(semantic_provider_->HasPendingUpdates());

  // Deletes node 5, which is a child of 4.
  EXPECT_TRUE(semantic_provider_->Delete(5u));

  // Spin the loop to process the deletion call.
  base::RunLoop().RunUntilIdle();

  // Commit is pending, because the parent still points to the child.
  EXPECT_TRUE(semantic_provider_->HasPendingUpdates());

  Node node_4;
  node_4.node_id(4u);
  node_4.child_ids({});
  EXPECT_TRUE(semantic_provider_->Update(std::move(node_4)));

  // Spin the loop to process the node update.
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(num_update_semantic_nodes_called_, 2u);
  EXPECT_EQ(num_delete_semantic_nodes_called_, 1u);

  EXPECT_FALSE(semantic_provider_->HasPendingUpdates());
}

TEST_F(AXFuchsiaSemanticProviderTest,
       SendsNodesOnlyAfterDanglingChildIsDeleted) {
  auto tree_nodes = TreeNodes();
  for (auto& node : tree_nodes) {
    EXPECT_TRUE(semantic_provider_->Update(std::move(node)));
  }

  // Spin the loop to process the queued update calls.
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(num_update_semantic_nodes_called_, 1u);
  EXPECT_FALSE(semantic_provider_->HasPendingUpdates());

  Node node_4;
  node_4.node_id(4u);
  node_4.child_ids({});  // This removes child 5.
  EXPECT_TRUE(semantic_provider_->Update(std::move(node_4)));

  // Spin the loop to process the update call.
  base::RunLoop().RunUntilIdle();

  EXPECT_TRUE(semantic_provider_->HasPendingUpdates());

  EXPECT_TRUE(semantic_provider_->Delete(5u));

  // Spin the loop to process the deletion.
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(num_update_semantic_nodes_called_, 2u);
  EXPECT_EQ(num_delete_semantic_nodes_called_, 1u);
  EXPECT_FALSE(semantic_provider_->HasPendingUpdates());
}

TEST_F(AXFuchsiaSemanticProviderTest, ReparentsNodeWithADeletion) {
  auto tree_nodes = TreeNodes();
  for (auto& node : tree_nodes) {
    EXPECT_TRUE(semantic_provider_->Update(std::move(node)));
  }

  // Spin the loop to process the queued update calls.
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(num_update_semantic_nodes_called_, 1u);
  EXPECT_FALSE(semantic_provider_->HasPendingUpdates());

  // Deletes node 4 to reparent its child (5).
  EXPECT_TRUE(semantic_provider_->Delete(4u));

  // Spin the loop to process the deletion.
  base::RunLoop().RunUntilIdle();

  EXPECT_TRUE(semantic_provider_->HasPendingUpdates());

  // Add child 5 to another node.
  Node node_1;
  node_1.node_id(1u);
  node_1.child_ids({{5u}});
  EXPECT_TRUE(semantic_provider_->Update(std::move(node_1)));

  // Spin the loop to process the update.
  base::RunLoop().RunUntilIdle();

  EXPECT_TRUE(semantic_provider_->HasPendingUpdates());

  Node node_4;
  node_4.node_id(4u);
  node_4.child_ids({});
  EXPECT_TRUE(semantic_provider_->Update(std::move(node_4)));

  // Spin the loop to process the update.
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(num_update_semantic_nodes_called_, 2u);
  EXPECT_EQ(num_delete_semantic_nodes_called_, 1u);
  EXPECT_FALSE(semantic_provider_->HasPendingUpdates());
}

TEST_F(AXFuchsiaSemanticProviderTest, ReparentsNodeWithAnUpdate) {
  auto tree_nodes = TreeNodes();
  for (auto& node : tree_nodes) {
    EXPECT_TRUE(semantic_provider_->Update(std::move(node)));
  }

  // Spin the loop to process the queued update calls.
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(num_update_semantic_nodes_called_, 1u);
  EXPECT_FALSE(semantic_provider_->HasPendingUpdates());

  // Add child 5 to another node. Note that 5 will have two parents, and the
  // commit must be held until it has only one.
  Node node_1;
  node_1.node_id(1u);
  node_1.child_ids({{5u}});
  EXPECT_TRUE(semantic_provider_->Update(std::move(node_1)));

  // Spin the loop to process the update.
  base::RunLoop().RunUntilIdle();

  EXPECT_TRUE(semantic_provider_->HasPendingUpdates());

  // Updates node 4 to no longer point to 5.
  Node node_4;
  node_4.node_id(4u);
  node_4.child_ids({});
  EXPECT_TRUE(semantic_provider_->Update(std::move(node_4)));

  // Spin the loop to process the update.
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(num_update_semantic_nodes_called_, 2u);
  EXPECT_EQ(num_delete_semantic_nodes_called_, 0u);
  EXPECT_FALSE(semantic_provider_->HasPendingUpdates());
}

TEST_F(AXFuchsiaSemanticProviderTest, ChangesRoot) {
  auto tree_nodes = TreeNodes();
  for (auto& node : tree_nodes) {
    EXPECT_TRUE(semantic_provider_->Update(std::move(node)));
  }

  // Spin the loop to process the queued updated calls.
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(num_update_semantic_nodes_called_, 1u);
  EXPECT_FALSE(semantic_provider_->HasPendingUpdates());

  Node new_root;
  new_root.node_id(0u);
  new_root.child_ids({{1u, 2u}});
  EXPECT_TRUE(semantic_provider_->Update(std::move(new_root)));

  // Spin the loop to process the update.
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(num_update_semantic_nodes_called_, 2u);
  EXPECT_EQ(num_delete_semantic_nodes_called_, 0u);
  EXPECT_FALSE(semantic_provider_->HasPendingUpdates());
}

TEST_F(AXFuchsiaSemanticProviderTest, BatchesUpdates) {
  std::vector<Node> updates;
  for (uint32_t i = 0; i < 30; ++i) {
    Node node;
    node.node_id(i);
    node.child_ids({{i + 1}});
    updates.push_back(std::move(node));
  }
  updates.back().child_ids()->clear();

  for (auto& node : updates) {
    EXPECT_TRUE(semantic_provider_->Update(std::move(node)));
  }

  // Spin the loop to process the queued update calls.
  base::RunLoop().RunUntilIdle();

  // 30 nodes in batches of 16 (default value of maximum nodes per update call),
  // should result in two update calls to the semantics API.
  EXPECT_EQ(num_update_semantic_nodes_called_, 2u);
  EXPECT_FALSE(semantic_provider_->HasPendingUpdates());
}

TEST_F(AXFuchsiaSemanticProviderTest, ClearsTree) {
  auto tree_nodes = TreeNodes();
  for (auto& node : tree_nodes) {
    EXPECT_TRUE(semantic_provider_->Update(std::move(node)));
  }

  // Spin the loop to process the queued update calls.
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(num_update_semantic_nodes_called_, 1u);
  EXPECT_FALSE(semantic_provider_->HasPendingUpdates());

  semantic_provider_->Clear();

  // Spin the loop to process the clear-tree call.
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(num_update_semantic_nodes_called_, 1u);
  EXPECT_EQ(num_delete_semantic_nodes_called_, 1u);
  EXPECT_FALSE(semantic_provider_->HasPendingUpdates());
}

TEST_F(AXFuchsiaSemanticProviderTest, UpdateScaleFactor) {
  // Send an initial root node update. At this point, the pixel scale is 1, the
  // root node's transform will be the identity matrix. Thus, the resulting
  // update sent to fuchsia should not contain a transform.
  {
    Node node;
    node.node_id(0u);
    // Set child_ids to make sure they're not overwritten later.
    node.child_ids({{1u}});
    semantic_provider_->Update(std::move(node));
    Node child;
    child.node_id(1u);
    semantic_provider_->Update(std::move(child));
  }

  // Spin the loop to process the queued update calls.
  base::RunLoop().RunUntilIdle();

  // Check that the first update sent to fuchsia reflects a pixel scale of 1.
  {
    ASSERT_EQ(node_updates().size(), 1u);
    const auto& first_update_batch = node_updates()[0];
    ASSERT_EQ(first_update_batch.size(), 2u);
    EXPECT_EQ(first_update_batch[0].node_id(), 0u);
    const fuchsia_accessibility_semantics::Node& node = first_update_batch[0];
    ASSERT_TRUE(node.node_to_container_transform().has_value());
    const auto& transform = node.node_to_container_transform()->matrix();
    EXPECT_EQ(transform[0], 1.f);
    EXPECT_EQ(transform[5], 1.f);
    ASSERT_EQ(node.child_ids()->size(), 1u);
    EXPECT_EQ(node.child_ids().value()[0], 1u);
  }

  // Now, set a new pixel scale != 1. This step should force an update to
  // fuchsia.
  const auto kPixelScale = 0.5f;
  semantic_provider_->SetPixelScale(kPixelScale);

  // Spin the loop to process the queued update calls.
  base::RunLoop().RunUntilIdle();

  // Check that the root node's node_to_conatiner_transform field was set when
  // the pixel scale was updated.
  {
    ASSERT_EQ(node_updates().size(), 2u);
    const auto& second_update_batch = node_updates()[1];
    ASSERT_EQ(second_update_batch.size(), 1u);
    const fuchsia_accessibility_semantics::Node& node = second_update_batch[0];
    EXPECT_EQ(node.node_id(), 0u);
    ASSERT_TRUE(node.node_to_container_transform().has_value());
    const auto& transform = node.node_to_container_transform()->matrix();
    EXPECT_EQ(transform[0], 1.f / kPixelScale);
    EXPECT_EQ(transform[5], 1.f / kPixelScale);
    ASSERT_EQ(node.child_ids()->size(), 1u);
    EXPECT_EQ(node.child_ids().value()[0], 1u);
  }

  // Finally, send one more update, and verify that the semantic provider
  // accounted for the new pixel scale in the root node's transform.
  {
    Node node;
    node.node_id(0u);
    node.child_ids({{1u}});
    semantic_provider_->Update(std::move(node));
  }

  // Spin the loop to process the queued update calls.
  base::RunLoop().RunUntilIdle();

  // Check that the root node's node_to_conatiner_transform field was set using
  // the new pixel scale.
  {
    ASSERT_EQ(node_updates().size(), 3u);
    const auto& third_update_batch = node_updates()[2];
    ASSERT_EQ(third_update_batch.size(), 1u);
    const fuchsia_accessibility_semantics::Node& node = third_update_batch[0];
    EXPECT_EQ(node.node_id(), 0u);
    ASSERT_TRUE(node.node_to_container_transform().has_value());
    const auto& transform = node.node_to_container_transform()->matrix();
    EXPECT_EQ(transform[0], 1.f / kPixelScale);
    EXPECT_EQ(transform[5], 1.f / kPixelScale);
    ASSERT_EQ(node.child_ids()->size(), 1u);
    EXPECT_EQ(node.child_ids().value()[0], 1u);
  }
}

}  // namespace
}  // namespace ui