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

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

#include <optional>

#include "base/memory/raw_ptr.h"
#include "base/test/bind.h"
#include "base/test/task_environment.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/accessibility/platform/ax_platform_node_delegate.h"
#include "ui/accessibility/platform/ax_unique_id.h"
#include "ui/accessibility/platform/fuchsia/accessibility_bridge_fuchsia_impl.h"
#include "ui/accessibility/platform/fuchsia/ax_platform_node_fuchsia.h"
#include "ui/accessibility/platform/fuchsia/semantic_provider.h"

namespace ui {
namespace {

class FakeSemanticProvider : public AXFuchsiaSemanticProvider {
 public:
  // AXFuchsiaSemanticProvider overrides.
  bool Update(fuchsia_accessibility_semantics::Node node) override {
    last_update_ = std::move(node);
    return true;
  }

  bool Delete(uint32_t node_id) override {
    last_deletion_ = node_id;
    return true;
  }

  bool Clear() override { return true; }

  void SendEvent(
      fuchsia_accessibility_semantics::SemanticEvent event) override {
    last_event_ = std::move(event);
  }

  bool HasPendingUpdates() const override { return false; }

  float GetPixelScale() const override { return pixel_scale_; }

  void SetPixelScale(float pixel_scale) override { pixel_scale_ = pixel_scale; }

  const std::optional<fuchsia_accessibility_semantics::Node>& last_update()
      const {
    return last_update_;
  }
  const std::optional<uint32_t>& last_deletion() const {
    return last_deletion_;
  }
  const std::optional<fuchsia_accessibility_semantics::SemanticEvent>&
  last_event() const {
    return last_event_;
  }

 private:
  std::optional<fuchsia_accessibility_semantics::Node> last_update_;
  std::optional<uint32_t> last_deletion_;
  std::optional<fuchsia_accessibility_semantics::SemanticEvent> last_event_;
  float pixel_scale_ = 1.f;
};

class FakeAXPlatformNodeDelegate : public AXPlatformNodeDelegate {
 public:
  FakeAXPlatformNodeDelegate() = default;
  ~FakeAXPlatformNodeDelegate() override = default;

  bool AccessibilityPerformAction(const AXActionData& data) override {
    last_action_data_.emplace(data);
    return true;
  }

  AXPlatformNodeId GetUniqueId() const override { return unique_id_; }

  const std::optional<AXActionData>& last_action_data() {
    return last_action_data_;
  }

  const AXNodeData& GetData() const override { return ax_node_data_; }
  void SetData(AXNodeData ax_node_data) { ax_node_data_ = ax_node_data; }

 private:
  std::optional<AXActionData> last_action_data_;
  const AXUniqueId unique_id_{AXUniqueId::Create()};
  AXNodeData ax_node_data_ = {};
};

class AccessibilityBridgeFuchsiaTest : public ::testing::Test {
 public:
  AccessibilityBridgeFuchsiaTest() = default;
  ~AccessibilityBridgeFuchsiaTest() override = default;

  void SetUp() override {
    mock_ax_platform_node_delegate_ =
        std::make_unique<FakeAXPlatformNodeDelegate>();
    auto mock_semantic_provider = std::make_unique<FakeSemanticProvider>();
    mock_semantic_provider_ = mock_semantic_provider.get();

    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);

    accessibility_bridge_ = std::make_unique<AccessibilityBridgeFuchsiaImpl>(
        /*root_window=*/nullptr, fidl::HLCPPToNatural(std::move(view_ref)),
        base::RepeatingCallback<void(bool)>(),
        base::RepeatingCallback<bool(zx_status_t)>(), inspect::Node());
    accessibility_bridge_->set_semantic_provider_for_test(
        std::move(mock_semantic_provider));
  }

 protected:
  // Required for zx::eventpair::create.
  base::test::SingleThreadTaskEnvironment task_environment_{
      base::test::SingleThreadTaskEnvironment::MainThreadType::IO};

  std::unique_ptr<FakeAXPlatformNodeDelegate> mock_ax_platform_node_delegate_;
  raw_ptr<FakeSemanticProvider> mock_semantic_provider_;
  std::unique_ptr<AccessibilityBridgeFuchsiaImpl> accessibility_bridge_;
};

TEST_F(AccessibilityBridgeFuchsiaTest, UpdateNode) {
  accessibility_bridge_->UpdateNode({{
      .node_id = 1u,
      .attributes = fuchsia_accessibility_semantics::Attributes{{
          .label = "label",
      }},
  }});

  const std::optional<fuchsia_accessibility_semantics::Node>& last_update =
      mock_semantic_provider_->last_update();

  ASSERT_TRUE(last_update.has_value());
  EXPECT_EQ(last_update->node_id(), 1u);
  ASSERT_TRUE(last_update->attributes());
  ASSERT_TRUE(last_update->attributes()->label().has_value());
  EXPECT_EQ(last_update->attributes()->label().value(), "label");
}

TEST_F(AccessibilityBridgeFuchsiaTest, UpdateNodeReplaceNodeID) {
  accessibility_bridge_->SetRootID(1u);

  fuchsia_accessibility_semantics::Node node;
  node.node_id(1u);

  accessibility_bridge_->UpdateNode(std::move(node));

  const std::optional<fuchsia_accessibility_semantics::Node>& last_update =
      mock_semantic_provider_->last_update();
  ASSERT_TRUE(last_update.has_value());
  EXPECT_EQ(last_update->node_id(),
            AXFuchsiaSemanticProvider::kFuchsiaRootNodeId);
}

TEST_F(AccessibilityBridgeFuchsiaTest, UpdateNodeReplaceOffsetContainerID) {
  accessibility_bridge_->SetRootID(1u);

  fuchsia_accessibility_semantics::Node node;
  node.node_id(2u);
  node.container_id(1u);

  accessibility_bridge_->UpdateNode(std::move(node));

  const std::optional<fuchsia_accessibility_semantics::Node>& last_update =
      mock_semantic_provider_->last_update();
  ASSERT_TRUE(last_update.has_value());
  ASSERT_TRUE(last_update->container_id().has_value());
  EXPECT_EQ(last_update->container_id().value(),
            AXFuchsiaSemanticProvider::kFuchsiaRootNodeId);
}

TEST_F(AccessibilityBridgeFuchsiaTest, SetRootIDDeletesOldRoot) {
  accessibility_bridge_->SetRootID(1u);
  accessibility_bridge_->SetRootID(2u);

  const std::optional<uint32_t>& last_deletion =
      mock_semantic_provider_->last_deletion();
  ASSERT_TRUE(last_deletion.has_value());
  EXPECT_EQ(*last_deletion, AXFuchsiaSemanticProvider::kFuchsiaRootNodeId);
}

TEST_F(AccessibilityBridgeFuchsiaTest, DeleteNode) {
  accessibility_bridge_->SetRootID(1u);

  // Delete a non-root node.
  accessibility_bridge_->DeleteNode(2u);

  const std::optional<uint32_t>& last_deletion =
      mock_semantic_provider_->last_deletion();
  ASSERT_TRUE(last_deletion.has_value());
  EXPECT_EQ(*last_deletion, 2u);
}

TEST_F(AccessibilityBridgeFuchsiaTest, DeleteRoot) {
  accessibility_bridge_->SetRootID(1u);

  // Delete root node.
  accessibility_bridge_->DeleteNode(1u);

  {
    const std::optional<uint32_t>& last_deletion =
        mock_semantic_provider_->last_deletion();
    ASSERT_TRUE(last_deletion.has_value());
    EXPECT_EQ(*last_deletion, AXFuchsiaSemanticProvider::kFuchsiaRootNodeId);
  }

  // Delete the node ID 1 again, and verify that it's no longer mapped to the
  // root.
  accessibility_bridge_->DeleteNode(1u);

  {
    const std::optional<uint32_t>& last_deletion =
        mock_semantic_provider_->last_deletion();
    ASSERT_TRUE(last_deletion.has_value());
    EXPECT_EQ(*last_deletion, 1u);
  }
}

TEST_F(AccessibilityBridgeFuchsiaTest, HitTest) {
  auto root_delegate = std::make_unique<FakeAXPlatformNodeDelegate>();
  AXPlatformNode::Pointer root_platform_node =
      AXPlatformNode::Create(*root_delegate);

  auto child_delegate = std::make_unique<FakeAXPlatformNodeDelegate>();
  AXPlatformNode::Pointer child_platform_node =
      AXPlatformNode::Create(*child_delegate);

  // Set the platform node as the root, so that the accessibility bridge
  // dispatches the hit test request to it.
  accessibility_bridge_->SetRootID(root_platform_node->GetUniqueId());

  fuchsia_math::PointF target_point = {{
      .x = 1.f,
      .y = 2.f,
  }};

  // Set hit_test_result to a nonsense value to ensure that it's modified
  // later.
  uint32_t hit_test_result = 100u;

  // Request a hit test. Note that the callback will not be invoked until
  // OnAccessibilityHitTestResult() is called.
  accessibility_bridge_->OnHitTest(
      target_point,
      base::BindLambdaForTesting(
          [&hit_test_result](
              const fidl::Response<
                  fuchsia_accessibility_semantics::SemanticListener::HitTest>&
                  response) {
            ASSERT_TRUE(response.result().node_id().has_value());
            hit_test_result = response.result().node_id().value();
          }));

  // Verify that the platform node's delegate received the hit test request.
  const std::optional<AXActionData>& action_data =
      root_delegate->last_action_data();
  ASSERT_TRUE(action_data.has_value());

  // The request_id field defaults to -1, so verify that it was set to a
  // non-negative value.
  EXPECT_GE(action_data->request_id, 0);
  EXPECT_EQ(action_data->target_point.x(), target_point.x());
  EXPECT_EQ(action_data->target_point.y(), target_point.y());
  EXPECT_EQ(action_data->action, ax::mojom::Action::kHitTest);

  // Simulate a hit test result. This should invoke the callback.
  uint32_t child_node_id =
      static_cast<uint32_t>(child_platform_node->GetUniqueId());
  accessibility_bridge_->OnAccessibilityHitTestResult(
      action_data->request_id, std::optional<uint32_t>(child_node_id));

  EXPECT_EQ(hit_test_result, static_cast<uint32_t>(child_node_id));
}

TEST_F(AccessibilityBridgeFuchsiaTest, HitTestReturnsRoot) {
  auto root_delegate = std::make_unique<FakeAXPlatformNodeDelegate>();
  AXPlatformNode::Pointer root_platform_node =
      AXPlatformNode::Create(*root_delegate);

  // Set the platform node as the root, so that the accessibility bridge
  // dispatches the hit test request to it.
  accessibility_bridge_->SetRootID(root_platform_node->GetUniqueId());

  fuchsia_math::PointF target_point = {{
      .x = 1.f,
      .y = 2.f,
  }};

  // Set hit_test_result to a nonsense value to ensure that it's modified
  // later.
  uint32_t hit_test_result = 100u;

  // Request a hit test. Note that the callback will not be invoked until
  // OnAccessibilityHitTestResult() is called.
  accessibility_bridge_->OnHitTest(
      target_point,
      base::BindLambdaForTesting(
          [&hit_test_result](
              const fidl::Response<
                  fuchsia_accessibility_semantics::SemanticListener::HitTest>&
                  response) {
            ASSERT_TRUE(response.result().node_id().has_value());
            hit_test_result = response.result().node_id().value();
          }));

  const std::optional<AXActionData>& action_data =
      root_delegate->last_action_data();
  ASSERT_TRUE(action_data.has_value());

  // Simulate a hit test result. This should invoke the callback.
  uint32_t root_node_id =
      static_cast<uint32_t>(root_platform_node->GetUniqueId());
  accessibility_bridge_->OnAccessibilityHitTestResult(
      action_data->request_id, std::optional<uint32_t>(root_node_id));

  EXPECT_EQ(hit_test_result, AXFuchsiaSemanticProvider::kFuchsiaRootNodeId);
}

TEST_F(AccessibilityBridgeFuchsiaTest, HitTestReturnsEmptyResult) {
  auto root_delegate = std::make_unique<FakeAXPlatformNodeDelegate>();
  AXPlatformNode::Pointer root_platform_node =
      AXPlatformNode::Create(*root_delegate);

  // Set the platform node as the root, so that the accessibility bridge
  // dispatches the hit test request to it.
  accessibility_bridge_->SetRootID(root_platform_node->GetUniqueId());

  fuchsia_math::PointF target_point{{
      .x = 1.f,
      .y = 2.f,
  }};

  // Request a hit test. Note that the callback will not be invoked until
  // OnAccessibilityHitTestResult() is called.
  bool callback_ran = false;
  accessibility_bridge_->OnHitTest(
      target_point,
      base::BindLambdaForTesting(
          [&callback_ran](
              const fidl::Response<
                  fuchsia_accessibility_semantics::SemanticListener::HitTest>&
                  response) {
            callback_ran = true;
            ASSERT_FALSE(response.result().node_id().has_value());
          }));

  const std::optional<AXActionData>& action_data =
      root_delegate->last_action_data();
  ASSERT_TRUE(action_data.has_value());

  // Simulate a hit test result. This should invoke the callback.
  accessibility_bridge_->OnAccessibilityHitTestResult(action_data->request_id,
                                                      {});

  // Verify that the callback ran. The callback itself will check that the hit
  // result was empty.
  EXPECT_TRUE(callback_ran);
}

TEST_F(AccessibilityBridgeFuchsiaTest, PerformActionOnRoot) {
  auto root_delegate = std::make_unique<FakeAXPlatformNodeDelegate>();
  AXPlatformNode::Pointer root_platform_node =
      AXPlatformNode::Create(*root_delegate);

  // Set the platform node as the root, so that the accessibility bridge
  // dispatches the hit test request to it.
  accessibility_bridge_->SetRootID(root_platform_node->GetUniqueId());

  // Perform DEFAULT action.
  accessibility_bridge_->OnAccessibilityAction(
      AXFuchsiaSemanticProvider::kFuchsiaRootNodeId,
      fuchsia_accessibility_semantics::Action::kDefault);

  const std::optional<AXActionData>& action_data =
      root_delegate->last_action_data();
  ASSERT_TRUE(action_data.has_value());
  EXPECT_EQ(action_data->action, ax::mojom::Action::kDoDefault);
}

TEST_F(AccessibilityBridgeFuchsiaTest, ScrollToMakeVisible) {
  auto delegate = std::make_unique<FakeAXPlatformNodeDelegate>();
  AXNodeData data;
  data.relative_bounds.bounds = gfx::RectF(
      /*x_min=*/1.f, /*y_min=*/2.f, /*width=*/3.f, /*height=*/4.f);
  delegate->SetData(data);
  AXPlatformNode::Pointer platform_node = AXPlatformNode::Create(*delegate);
  ASSERT_TRUE(platform_node);

  // Request a SHOW_ON_SCREEN action.
  accessibility_bridge_->OnAccessibilityAction(
      delegate->GetUniqueId(),
      fuchsia_accessibility_semantics::Action::kShowOnScreen);

  const std::optional<AXActionData>& action_data = delegate->last_action_data();
  ASSERT_TRUE(action_data.has_value());
  EXPECT_EQ(action_data->action, ax::mojom::Action::kScrollToMakeVisible);

  // The target rect should have the same size as the node's bounds, but
  // should have (x, y) == (0, 0).
  EXPECT_EQ(action_data->target_rect.x(), 0.f);
  EXPECT_EQ(action_data->target_rect.y(), 0.f);
  EXPECT_EQ(action_data->target_rect.width(), 3.f);
  EXPECT_EQ(action_data->target_rect.height(), 4.f);
}

}  // namespace
}  // namespace ui