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

#include "components/exo/wayland/wayland_protocol_logger.h"

#include <wayland-server-core.h>
#include <wayland-util.h>
#include <xdg-shell-client-protocol.h>
#include <xdg-shell-server-protocol.h>

#include "base/strings/strcat.h"
#include "base/strings/string_number_conversions.h"
#include "components/exo/wayland/test/client_util.h"
#include "components/exo/wayland/test/resource_key.h"
#include "components/exo/wayland/test/server_util.h"
#include "components/exo/wayland/test/wayland_server_test.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace exo::wayland {
namespace {

class WaylandProtocolLoggerTest : public test::WaylandServerTest {
 public:
  WaylandProtocolLoggerTest() = default;
  WaylandProtocolLoggerTest(const WaylandProtocolLoggerTest&) = delete;
  WaylandProtocolLoggerTest& operator=(const WaylandProtocolLoggerTest&) =
      delete;
  ~WaylandProtocolLoggerTest() override = default;

  // test::WaylandServerTest:
  void SetUp() override {
    WaylandProtocolLogger::SetHandlerFuncForTesting(
        [](void* user_data, wl_protocol_logger_type type,
           const wl_protocol_logger_message* message) {
          messages_.push_back(
              WaylandProtocolLogger::FormatMessage(type, message));
        });
    test::WaylandServerTest::SetUp();

    // Ignore messages from this test case's setup phase.
    messages_.clear();
  }

  // test::WaylandServerTest:
  void TearDown() override {
    messages_.clear();
    test::WaylandServerTest::TearDown();
  }

  static std::vector<std::vector<std::string>> messages_;
};

std::vector<std::vector<std::string>> WaylandProtocolLoggerTest::messages_ = {};

class ClientData : public test::TestClient::CustomData {
 public:
  ClientData()
      : callback(nullptr, &wl_callback_destroy),
        data_source(nullptr, &wl_data_source_destroy),
        pointer(nullptr, &wl_pointer_destroy),
        surface(nullptr, &wl_surface_destroy),
        xdg_surface(nullptr, &xdg_surface_destroy),
        xdg_toplevel(nullptr, &xdg_toplevel_destroy) {}
  ~ClientData() override = default;

  std::unique_ptr<wl_callback, decltype(&wl_callback_destroy)> callback;
  std::unique_ptr<wl_data_source, decltype(&wl_data_source_destroy)>
      data_source;
  std::unique_ptr<wl_pointer, decltype(&wl_pointer_destroy)> pointer;
  std::unique_ptr<wl_surface, decltype(&wl_surface_destroy)> surface;
  std::unique_ptr<xdg_surface, decltype(&xdg_surface_destroy)> xdg_surface;
  std::unique_ptr<xdg_toplevel, decltype(&xdg_toplevel_destroy)> xdg_toplevel;
};

std::string ProxyId(void* proxy) {
  return base::NumberToString(
      wl_proxy_get_id(reinterpret_cast<wl_proxy*>(proxy)));
}

void AddState(wl_array* states, xdg_toplevel_state state) {
  xdg_toplevel_state* value = static_cast<xdg_toplevel_state*>(
      wl_array_add(states, sizeof(xdg_toplevel_state)));
  DCHECK(value);
  *value = state;
}

}  // namespace

TEST_F(WaylandProtocolLoggerTest, LogsBasicRequest) {
  std::string surface_id;
  std::string compositor_id;

  PostToClientAndWait([&](test::TestClient* client) {
    auto* data = client->set_data(std::make_unique<ClientData>());
    data->surface.reset(wl_compositor_create_surface(client->compositor()));
    compositor_id = ProxyId(client->compositor());
    surface_id = ProxyId(data->surface.get());
  });

  EXPECT_THAT(messages_,
              ::testing::Contains(::testing::ElementsAre(
                  base::StrCat({"Received request: wl_compositor@",
                                compositor_id, ".create_surface"}),
                  base::StrCat({"new id wl_surface@", surface_id}))));
}

TEST_F(WaylandProtocolLoggerTest, LogsBasicEvent) {
  std::string callback_id;

  EXPECT_THAT(messages_, ::testing::IsEmpty());

  PostToClientAndWait([&](test::TestClient* client) {
    auto* data = client->set_data(std::make_unique<ClientData>());
    data->callback.reset(wl_display_sync(client->display()));
    callback_id = ProxyId(data->callback.get());
  });

  EXPECT_THAT(messages_,
              ::testing::Contains(::testing::Contains(base::StrCat(
                  {"Sent event: wl_callback@", callback_id, ".done"}))));
}

TEST_F(WaylandProtocolLoggerTest, LogsObjects) {
  std::string xdg_wm_base_id;
  std::string xdg_surface_id;
  std::string surface_id;

  PostToClientAndWait([&](test::TestClient* client) {
    auto* data = client->set_data(std::make_unique<ClientData>());
    xdg_wm_base_id = ProxyId(client->xdg_wm_base());
    data->surface.reset(wl_compositor_create_surface(client->compositor()));
    data->xdg_surface.reset(xdg_wm_base_get_xdg_surface(client->xdg_wm_base(),
                                                        data->surface.get()));
    surface_id = ProxyId(data->surface.get());
    xdg_surface_id = ProxyId(data->xdg_surface.get());
  });

  EXPECT_THAT(messages_,
              ::testing::Contains(::testing::ElementsAre(
                  base::StrCat({"Received request: xdg_wm_base@",
                                xdg_wm_base_id, ".get_xdg_surface"}),
                  base::StrCat({"new id xdg_surface@", xdg_surface_id}),
                  base::StrCat({"wl_surface@", surface_id}))));
}

TEST_F(WaylandProtocolLoggerTest, LogsStrings) {
  constexpr const char* window_title = "🦄🌈 I ♥️ UTF-8 😋";
  std::string xdg_toplevel_id;

  PostToClientAndWait([&](test::TestClient* client) {
    auto* data = client->set_data(std::make_unique<ClientData>());
    data->surface.reset(wl_compositor_create_surface(client->compositor()));
    data->xdg_surface.reset(xdg_wm_base_get_xdg_surface(client->xdg_wm_base(),
                                                        data->surface.get()));
    data->xdg_toplevel.reset(xdg_surface_get_toplevel(data->xdg_surface.get()));
    xdg_toplevel_set_title(data->xdg_toplevel.get(), window_title);
    xdg_toplevel_id = ProxyId(data->xdg_toplevel.get());
  });

  EXPECT_THAT(messages_, ::testing::Contains(::testing::ElementsAre(
                             base::StrCat({"Received request: xdg_toplevel@",
                                           xdg_toplevel_id, ".set_title"}),
                             window_title)));
}

// TODO(b/335767378): triggers dangling pointer detection.
TEST_F(WaylandProtocolLoggerTest, DISABLED_LogsObjectsAndStrings) {
  std::string display_id;
  constexpr uint32_t fake_error_code = 0x12345678u;
  constexpr const char* fake_error = "🦄🌈 Fake error 😋";
  EXPECT_THAT(messages_, ::testing::IsEmpty());

  PostToClientAndWait([&](test::TestClient* client) {
    wl_resource_post_error(test::server_util::LookUpResource(
                               server_.get(), test::client_util::GetResourceKey(
                                                  client->display())),
                           fake_error_code, "%s", fake_error);
    display_id = ProxyId(client->display());
  });

  EXPECT_THAT(
      messages_,
      ::testing::Contains(::testing::ElementsAre(
          base::StrCat({"Sent event: wl_display@", display_id, ".error"}),
          base::StrCat({"wl_display@", display_id}),
          base::NumberToString(fake_error_code), fake_error)));
}

TEST_F(WaylandProtocolLoggerTest, LogsFileDescriptors) {
  std::string data_source_id;
  test::ResourceKey data_source_resource_key;

  PostToClientAndWait([&](test::TestClient* client) {
    auto* data = client->set_data(std::make_unique<ClientData>());
    data->data_source.reset(wl_data_device_manager_create_data_source(
        client->data_device_manager()));
    data_source_id = ProxyId(data->data_source.get());
    data_source_resource_key =
        test::client_util::GetResourceKey(data->data_source.get());
  });

  wl_resource* data_source_resource = test::server_util::LookUpResource(
      server_.get(), data_source_resource_key);
  EXPECT_NE(data_source_resource, nullptr);

  // Actually sending a wl_data_source::send event requires a valid file
  // descriptor, which requires some ceremony to set up properly.
  // Instead, call the message formatting utility directly.
  const struct wl_interface* arg_types[2] = {nullptr, nullptr};
  wl_message message = {
      .name = "send", .signature = "sh", .types = &arg_types[0]};
  wl_argument args[] = {{.s = "text/plain"}, {.h = 12345}};
  wl_protocol_logger_message logger_message = {
      .resource = data_source_resource,
      .message_opcode = WL_DATA_SOURCE_SEND,
      .message = &message,
      .arguments_count = 2,
      .arguments = &args[0],
  };

  auto result = WaylandProtocolLogger::FormatMessage(WL_PROTOCOL_LOGGER_EVENT,
                                                     &logger_message);
  EXPECT_THAT(result, ::testing::ElementsAre(
                          base::StrCat({"Sent event: wl_data_source@",
                                        data_source_id, ".send"}),
                          "text/plain", "fd 12345"));
}

TEST_F(WaylandProtocolLoggerTest, LogsFixedPointNumbers) {
  // Arrange: Create a wl_pointer client object, wait for server to receive.
  std::string pointer_id;
  test::ResourceKey pointer_resource_key;

  PostToClientAndWait([&](test::TestClient* client) {
    auto* data = client->set_data(std::make_unique<ClientData>());
    data->pointer.reset(wl_seat_get_pointer(client->seat()));
    pointer_id = ProxyId(data->pointer.get());
    pointer_resource_key =
        test::client_util::GetResourceKey(data->pointer.get());
  });

  // Act: Send a motion event
  wl_resource* pointer_resource =
      test::server_util::LookUpResource(server_.get(), pointer_resource_key);
  EXPECT_NE(pointer_resource, nullptr);

  wl_pointer_send_motion(pointer_resource, 123, wl_fixed_from_double(1234.5),
                         wl_fixed_from_double(0));

  // Assert: Motion event correctly logged
  EXPECT_THAT(
      messages_,
      ::testing::Contains(::testing::ElementsAre(
          base::StrCat({"Sent event: wl_pointer@", pointer_id, ".motion"}),
          "123", "1234.5", "0")));
}

TEST_F(WaylandProtocolLoggerTest, LogsArrays) {
  std::string xdg_toplevel_id;
  test::ResourceKey xdg_toplevel_resource_key;

  PostToClientAndWait([&](test::TestClient* client) {
    auto* data = client->set_data(std::make_unique<ClientData>());
    data->surface.reset(wl_compositor_create_surface(client->compositor()));
    data->xdg_surface.reset(xdg_wm_base_get_xdg_surface(client->xdg_wm_base(),
                                                        data->surface.get()));
    data->xdg_toplevel.reset(xdg_surface_get_toplevel(data->xdg_surface.get()));
    xdg_toplevel_id = ProxyId(data->xdg_toplevel.get());
    xdg_toplevel_resource_key =
        test::client_util::GetResourceKey(data->xdg_toplevel.get());
  });

  wl_resource* xdg_toplevel_resource = test::server_util::LookUpResource(
      server_.get(), xdg_toplevel_resource_key);
  EXPECT_NE(xdg_toplevel_resource, nullptr);

  // Act: Send a typical configure event.
  {
    messages_.clear();
    wl_array states;
    wl_array_init(&states);
    AddState(&states, XDG_TOPLEVEL_STATE_ACTIVATED);
    AddState(&states, XDG_TOPLEVEL_STATE_FULLSCREEN);
    xdg_toplevel_send_configure(xdg_toplevel_resource, 1024, 768, &states);
    wl_array_release(&states);
  }

  // Assert: Short arrays print correctly.
  EXPECT_THAT(messages_,
              ::testing::Contains(::testing::ElementsAre(
                  base::StrCat({"Sent event: xdg_toplevel@", xdg_toplevel_id,
                                ".configure"}),
                  "1024", "768", "array[8 bytes]{0400000002000000}")));

  // Act: Send a very long array.
  {
    messages_.clear();
    wl_array states;
    wl_array_init(&states);
    for (int i = 0; i < 14; i++) {
      AddState(&states, XDG_TOPLEVEL_STATE_ACTIVATED);
    }
    xdg_toplevel_send_configure(xdg_toplevel_resource, 1024, 768, &states);
    wl_array_release(&states);
  }

  // Assert: Long arrays truncate as expected.
  EXPECT_THAT(messages_,
              ::testing::Contains(::testing::ElementsAre(
                  base::StrCat({"Sent event: xdg_toplevel@", xdg_toplevel_id,
                                ".configure"}),
                  "1024", "768",
                  "array[56 bytes]"
                  "{04000000040000000400000004000000040000000400000004000000"
                  "0400000004000000040000000400000004000000...}")));
}

}  // namespace exo::wayland