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

#include "content/browser/notifications/notification_database_conversions.h"

#include <stddef.h>
#include <stdint.h>

#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/time/time.h"
#include "content/browser/notifications/notification_database_data.pb.h"
#include "content/browser/notifications/notification_database_resources.pb.h"
#include "content/public/browser/notification_database_data.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
#include "third_party/blink/public/common/notifications/notification_constants.h"
#include "third_party/blink/public/common/notifications/notification_resources.h"
#include "third_party/blink/public/mojom/notifications/notification.mojom.h"
#include "third_party/skia/include/core/SkBitmap.h"

namespace content {

namespace {

SkBitmap CreateBitmap(int width, int height, SkColor color) {
  SkBitmap bitmap;
  bitmap.allocN32Pixels(width, height);
  bitmap.eraseColor(color);
  return bitmap;
}

}  // namespace

const char kNotificationId[] = "my-notification";
const int64_t kServiceWorkerRegistrationId = 9001;
const bool kReplacedExistingNotification = true;
const int kNumClicks = 8;
const int kNumActionButtonClicks = 9;
const double kInitTimeMillis = 12345;
const int kTimeUntilFirstClickMillis = 11111;
const int kTimeUntilLastClickMillis = 22222;
const int kTimeUntilCloseMillis = 33333;

const blink::mojom::NotificationActionType kNotificationActionType =
    blink::mojom::NotificationActionType::TEXT;
const char kOrigin[] = "https://example.com/";
const char16_t kNotificationTitle[] = u"My Notification";
const char kNotificationLang[] = "nl";
const char16_t kNotificationBody[] = u"Hello, world!";
const char kNotificationTag[] = "my_tag";
const char kNotificationImageUrl[] = "https://example.com/image.jpg";
const char kNotificationIconUrl[] = "https://example.com/icon.png";
const char kNotificationBadgeUrl[] = "https://example.com/badge.png";
const char kNotificationActionIconUrl[] = "https://example.com/action_icon.png";
const int kNotificationVibrationPattern[] = {100, 200, 300};
const double kNotificationTimestamp = 621046800.;
const unsigned char kNotificationData[] = {0xdf, 0xff, 0x0, 0x0, 0xff, 0xdf};
const double kShowTriggerTimestamp = 621086800.;
const bool kHasTriggered = true;

TEST(NotificationDatabaseConversionsTest, SerializeAndDeserializeData) {
  std::vector<int> vibration_pattern(
      kNotificationVibrationPattern,
      kNotificationVibrationPattern + std::size(kNotificationVibrationPattern));

  std::vector<char> developer_data(
      kNotificationData, kNotificationData + std::size(kNotificationData));

  blink::PlatformNotificationData notification_data;
  notification_data.title = kNotificationTitle;
  notification_data.direction =
      blink::mojom::NotificationDirection::RIGHT_TO_LEFT;
  notification_data.lang = kNotificationLang;
  notification_data.body = kNotificationBody;
  notification_data.tag = kNotificationTag;
  notification_data.image = GURL(kNotificationImageUrl);
  notification_data.icon = GURL(kNotificationIconUrl);
  notification_data.badge = GURL(kNotificationBadgeUrl);
  notification_data.vibration_pattern = vibration_pattern;
  notification_data.timestamp = base::Time::FromJsTime(kNotificationTimestamp);
  notification_data.renotify = true;
  notification_data.silent = true;
  notification_data.require_interaction = true;
  notification_data.show_trigger_timestamp =
      base::Time::FromJsTime(kShowTriggerTimestamp);
  notification_data.data = developer_data;
  for (size_t i = 0; i < blink::kNotificationMaxActions; i++) {
    auto notification_action = blink::mojom::NotificationAction::New();
    notification_action->type = kNotificationActionType;
    notification_action->action = base::NumberToString(i);
    notification_action->title = base::NumberToString16(i);
    notification_action->icon = GURL(kNotificationActionIconUrl);
    notification_action->placeholder = base::NumberToString16(i);
    notification_data.actions.push_back(std::move(notification_action));
  }

  NotificationDatabaseData database_data;
  database_data.notification_id = kNotificationId;
  database_data.origin = GURL(kOrigin);
  database_data.service_worker_registration_id = kServiceWorkerRegistrationId;
  database_data.notification_data = notification_data;
  database_data.replaced_existing_notification = kReplacedExistingNotification;
  database_data.num_clicks = kNumClicks;
  database_data.num_action_button_clicks = kNumActionButtonClicks;
  database_data.creation_time_millis = base::Time::FromDoubleT(kInitTimeMillis);
  database_data.time_until_first_click_millis =
      base::Milliseconds(kTimeUntilFirstClickMillis);
  database_data.time_until_last_click_millis =
      base::Milliseconds(kTimeUntilLastClickMillis);
  database_data.time_until_close_millis =
      base::Milliseconds(kTimeUntilCloseMillis);
  database_data.closed_reason = NotificationDatabaseData::ClosedReason::USER;
  database_data.has_triggered = kHasTriggered;
  database_data.is_shown_by_browser = true;
  std::string serialized_data;

  // Serialize the data in |notification_data| to the string |serialized_data|.
  ASSERT_TRUE(
      SerializeNotificationDatabaseData(database_data, &serialized_data));

  NotificationDatabaseData copied_data;

  // Deserialize the data in |serialized_data| to |copied_data|.
  ASSERT_TRUE(
      DeserializeNotificationDatabaseData(serialized_data, &copied_data));

  EXPECT_EQ(database_data.notification_id, copied_data.notification_id);
  EXPECT_EQ(database_data.origin, copied_data.origin);
  EXPECT_EQ(database_data.service_worker_registration_id,
            copied_data.service_worker_registration_id);
  EXPECT_EQ(database_data.num_clicks, copied_data.num_clicks);
  EXPECT_EQ(database_data.num_action_button_clicks,
            copied_data.num_action_button_clicks);
  EXPECT_EQ(database_data.replaced_existing_notification,
            copied_data.replaced_existing_notification);
  EXPECT_EQ(database_data.creation_time_millis,
            copied_data.creation_time_millis);
  EXPECT_EQ(database_data.time_until_first_click_millis,
            copied_data.time_until_first_click_millis);
  EXPECT_EQ(database_data.time_until_last_click_millis,
            copied_data.time_until_last_click_millis);
  EXPECT_EQ(database_data.time_until_close_millis,
            copied_data.time_until_close_millis);
  EXPECT_EQ(database_data.closed_reason, copied_data.closed_reason);
  EXPECT_EQ(database_data.has_triggered, copied_data.has_triggered);
  EXPECT_EQ(database_data.is_shown_by_browser, copied_data.is_shown_by_browser);

  const blink::PlatformNotificationData& copied_notification_data =
      copied_data.notification_data;

  EXPECT_EQ(notification_data.title, copied_notification_data.title);
  EXPECT_EQ(notification_data.direction, copied_notification_data.direction);
  EXPECT_EQ(notification_data.lang, copied_notification_data.lang);
  EXPECT_EQ(notification_data.body, copied_notification_data.body);
  EXPECT_EQ(notification_data.tag, copied_notification_data.tag);
  EXPECT_EQ(notification_data.image, copied_notification_data.image);
  EXPECT_EQ(notification_data.icon, copied_notification_data.icon);
  EXPECT_EQ(notification_data.badge, copied_notification_data.badge);

  EXPECT_THAT(copied_notification_data.vibration_pattern,
              testing::ElementsAreArray(kNotificationVibrationPattern));

  EXPECT_EQ(notification_data.timestamp, copied_notification_data.timestamp);
  EXPECT_EQ(notification_data.renotify, copied_notification_data.renotify);
  EXPECT_EQ(notification_data.silent, copied_notification_data.silent);
  EXPECT_EQ(notification_data.require_interaction,
            copied_notification_data.require_interaction);
  EXPECT_EQ(notification_data.show_trigger_timestamp,
            copied_notification_data.show_trigger_timestamp);

  ASSERT_EQ(developer_data.size(), copied_notification_data.data.size());
  for (size_t i = 0; i < developer_data.size(); ++i)
    EXPECT_EQ(developer_data[i], copied_notification_data.data[i]);

  ASSERT_EQ(notification_data.actions.size(),
            copied_notification_data.actions.size());
  for (size_t i = 0; i < notification_data.actions.size(); ++i) {
    EXPECT_EQ(notification_data.actions[i]->type,
              copied_notification_data.actions[i]->type);
    EXPECT_EQ(notification_data.actions[i]->action,
              copied_notification_data.actions[i]->action);
    EXPECT_EQ(notification_data.actions[i]->title,
              copied_notification_data.actions[i]->title);
    EXPECT_EQ(notification_data.actions[i]->icon,
              copied_notification_data.actions[i]->icon);
    EXPECT_EQ(notification_data.actions[i]->placeholder,
              copied_notification_data.actions[i]->placeholder);
    EXPECT_TRUE(copied_notification_data.actions[i]->placeholder);
  }
}

TEST(NotificationDatabaseConversionsTest, ActionDeserializationIsNotAdditive) {
  NotificationDatabaseData database_data;

  for (size_t i = 0; i < blink::kNotificationMaxActions; ++i) {
    database_data.notification_data.actions.emplace_back(
        blink::mojom::NotificationAction::New());
  }

  std::string serialized_data;
  NotificationDatabaseData copied_database_data;

  // Serialize the data in |notification_data| to the string |serialized_data|,
  // and then deserialize it again immediately to |copied_database_data|.
  ASSERT_TRUE(
      SerializeNotificationDatabaseData(database_data, &serialized_data));
  ASSERT_TRUE(DeserializeNotificationDatabaseData(serialized_data,
                                                  &copied_database_data));

  EXPECT_EQ(copied_database_data.notification_data.actions.size(),
            blink::kNotificationMaxActions);

  // Deserialize it again in the same |copied_database_data|. The number of
  // actions in the structure should not be affected.
  ASSERT_TRUE(DeserializeNotificationDatabaseData(serialized_data,
                                                  &copied_database_data));

  EXPECT_EQ(copied_database_data.notification_data.actions.size(),
            blink::kNotificationMaxActions);
}

TEST(NotificationDatabaseConversionsTest, SerializeAndDeserializeActionTypes) {
  blink::mojom::NotificationActionType action_types[] = {
      blink::mojom::NotificationActionType::BUTTON,
      blink::mojom::NotificationActionType::TEXT};

  for (blink::mojom::NotificationActionType action_type : action_types) {
    blink::PlatformNotificationData notification_data;

    auto action = blink::mojom::NotificationAction::New();
    action->type = action_type;
    notification_data.actions.push_back(std::move(action));

    NotificationDatabaseData database_data;
    database_data.notification_data = notification_data;

    std::string serialized_data;
    ASSERT_TRUE(
        SerializeNotificationDatabaseData(database_data, &serialized_data));

    NotificationDatabaseData copied_data;
    ASSERT_TRUE(
        DeserializeNotificationDatabaseData(serialized_data, &copied_data));

    EXPECT_EQ(action_type, copied_data.notification_data.actions[0]->type);
  }
}

TEST(NotificationDatabaseConversionsTest, SerializeAndDeserializeDirections) {
  blink::mojom::NotificationDirection directions[] = {
      blink::mojom::NotificationDirection::LEFT_TO_RIGHT,
      blink::mojom::NotificationDirection::RIGHT_TO_LEFT,
      blink::mojom::NotificationDirection::AUTO};

  for (size_t i = 0; i < std::size(directions); ++i) {
    blink::PlatformNotificationData notification_data;
    notification_data.direction = directions[i];

    NotificationDatabaseData database_data;
    database_data.notification_data = notification_data;

    std::string serialized_data;
    ASSERT_TRUE(
        SerializeNotificationDatabaseData(database_data, &serialized_data));

    NotificationDatabaseData copied_data;
    ASSERT_TRUE(
        DeserializeNotificationDatabaseData(serialized_data, &copied_data));

    EXPECT_EQ(directions[i], copied_data.notification_data.direction);
  }
}

TEST(NotificationDatabaseConversionsTest,
     SerializeAndDeserializeClosedReasons) {
  NotificationDatabaseData::ClosedReason closed_reasons[] = {
      NotificationDatabaseData::ClosedReason::USER,
      NotificationDatabaseData::ClosedReason::DEVELOPER,
      NotificationDatabaseData::ClosedReason::UNKNOWN};

  for (size_t i = 0; i < std::size(closed_reasons); ++i) {
    NotificationDatabaseData database_data;
    database_data.closed_reason = closed_reasons[i];

    std::string serialized_data;
    ASSERT_TRUE(
        SerializeNotificationDatabaseData(database_data, &serialized_data));

    NotificationDatabaseData copied_data;
    ASSERT_TRUE(
        DeserializeNotificationDatabaseData(serialized_data, &copied_data));

    EXPECT_EQ(closed_reasons[i], copied_data.closed_reason);
  }
}

TEST(NotificationDatabaseConversionsTest,
     SerializeAndDeserializeNullPlaceholder) {
  auto action = blink::mojom::NotificationAction::New();
  action->type = kNotificationActionType;
  action->placeholder = absl::nullopt;  // null string.

  blink::PlatformNotificationData notification_data;
  notification_data.actions.push_back(std::move(action));

  NotificationDatabaseData database_data;
  database_data.notification_data = notification_data;

  std::string serialized_data;
  ASSERT_TRUE(
      SerializeNotificationDatabaseData(database_data, &serialized_data));

  NotificationDatabaseData copied_data;
  ASSERT_TRUE(
      DeserializeNotificationDatabaseData(serialized_data, &copied_data));

  EXPECT_FALSE(copied_data.notification_data.actions[0]->placeholder);
}

TEST(NotificationDatabaseConversionsTest,
     SerializeAndDeserializeNullShowTriggerTimestamp) {
  blink::PlatformNotificationData notification_data;

  // explicitly empty timestamp
  notification_data.show_trigger_timestamp = absl::nullopt;

  NotificationDatabaseData database_data;
  database_data.notification_data = notification_data;

  std::string serialized_data;
  ASSERT_TRUE(
      SerializeNotificationDatabaseData(database_data, &serialized_data));

  NotificationDatabaseData copied_data;
  ASSERT_TRUE(
      DeserializeNotificationDatabaseData(serialized_data, &copied_data));

  EXPECT_FALSE(
      copied_data.notification_data.show_trigger_timestamp.has_value());
}

TEST(NotificationDatabaseConversionsTest, OptionalFieldsGetCleared) {
  NotificationDatabaseData data_without_fields;
  NotificationDatabaseData data_with_fields;

  data_with_fields.time_until_close_millis = base::Seconds(1);
  data_with_fields.time_until_first_click_millis = base::Seconds(2);
  data_with_fields.time_until_last_click_millis = base::Seconds(3);
  data_with_fields.notification_resources = blink::NotificationResources();

  std::string serialized_data;
  NotificationDatabaseData copied_database_data;

  // Serialize the |data_with_fields| to the string |serialized_data|,
  // and then deserialize it again immediately to |copied_database_data|.
  ASSERT_TRUE(
      SerializeNotificationDatabaseData(data_with_fields, &serialized_data));
  ASSERT_TRUE(DeserializeNotificationDatabaseData(serialized_data,
                                                  &copied_database_data));

  EXPECT_EQ(base::Seconds(1), copied_database_data.time_until_close_millis);
  EXPECT_EQ(base::Seconds(2),
            copied_database_data.time_until_first_click_millis);
  EXPECT_EQ(base::Seconds(3),
            copied_database_data.time_until_last_click_millis);
  EXPECT_FALSE(copied_database_data.notification_resources.has_value());

  // Deserialize the |data_without_fields| in the same |copied_database_data|.
  // The optional fields should now be gone.
  ASSERT_TRUE(
      SerializeNotificationDatabaseData(data_without_fields, &serialized_data));
  ASSERT_TRUE(DeserializeNotificationDatabaseData(serialized_data,
                                                  &copied_database_data));

  EXPECT_FALSE(copied_database_data.time_until_close_millis.has_value());
  EXPECT_FALSE(copied_database_data.time_until_first_click_millis.has_value());
  EXPECT_FALSE(copied_database_data.time_until_last_click_millis.has_value());
  EXPECT_FALSE(copied_database_data.notification_resources.has_value());
}

TEST(NotificationDatabaseConversionsTest,
     SerializeAndDeserializeNotificationResources) {
  blink::NotificationResources notification_resources;

  notification_resources.notification_icon = CreateBitmap(10, 10, SK_ColorBLUE);
  notification_resources.image = CreateBitmap(20, 20, SK_ColorGREEN);
  notification_resources.badge = CreateBitmap(30, 30, SK_ColorRED);

  notification_resources.action_icons.push_back(
      CreateBitmap(40, 40, SK_ColorYELLOW));
  notification_resources.action_icons.push_back(
      CreateBitmap(41, 41, SK_ColorCYAN));
  notification_resources.action_icons.push_back(
      CreateBitmap(42, 42, SK_ColorMAGENTA));

  std::string serialized_resources;
  ASSERT_TRUE(SerializeNotificationDatabaseResources(notification_resources,
                                                     &serialized_resources));

  blink::NotificationResources copied_resources;
  ASSERT_TRUE(DeserializeNotificationDatabaseResources(serialized_resources,
                                                       &copied_resources));

  EXPECT_EQ(10, copied_resources.notification_icon.width());
  EXPECT_EQ(20, copied_resources.image.width());
  EXPECT_EQ(30, copied_resources.badge.width());
  EXPECT_EQ(3u, copied_resources.action_icons.size());
  EXPECT_EQ(40, copied_resources.action_icons[0].width());
  EXPECT_EQ(41, copied_resources.action_icons[1].width());
  EXPECT_EQ(42, copied_resources.action_icons[2].width());
}

}  // namespace content