// 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 "chromeos/ash/components/phonehub/notification_processor.h"

#include "ash/constants/ash_features.h"
#include "base/barrier_closure.h"
#include "base/functional/callback.h"
#include "base/strings/utf_string_conversions.h"
#include "base/time/time.h"
#include "chromeos/ash/components/multidevice/logging/logging.h"
#include "chromeos/ash/components/phonehub/notification.h"
#include "chromeos/ash/components/phonehub/notification_manager.h"
#include "services/data_decoder/public/cpp/decode_image.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/gfx/color_palette.h"
#include "ui/gfx/image/image_skia.h"

namespace ash::phonehub {

namespace {

// Constants to override the Messages app monochrome icon color.
const char kMessagesPackageName[] = "com.google.android.apps.messaging";
const SkColor kMessagesOverrideColor = gfx::kGoogleBlue600;

std::optional<SkColor> getMonochromeIconColor(const proto::Notification& proto,
                                              const gfx::Image& icon) {
  if (icon.IsEmpty() || !proto.origin_app().has_monochrome_icon_color()) {
    return std::nullopt;
  }

  if (proto.origin_app().package_name() == kMessagesPackageName) {
    // The notification color supplied by the Messages app (Bugle) is based
    // on light/dark mode of the phone, not the Chromebook, with no way to
    // query for both at runtime. These constants are used to override with
    // a fixed color. See conversation at b/207089786 for more details.
    return kMessagesOverrideColor;
  }

  return SkColorSetRGB(proto.origin_app().monochrome_icon_color().red(),
                       proto.origin_app().monochrome_icon_color().green(),
                       proto.origin_app().monochrome_icon_color().blue());
}

Notification::Importance GetNotificationImportanceFromProto(
    proto::NotificationImportance importance) {
  switch (importance) {
    case proto::NotificationImportance::UNSPECIFIED:
      return Notification::Importance::kUnspecified;
    case proto::NotificationImportance::NONE:
      return Notification::Importance::kNone;
    case proto::NotificationImportance::MIN:
      return Notification::Importance::kMin;
    case proto::NotificationImportance::LOW:
      return Notification::Importance::kLow;
    case proto::NotificationImportance::DEFAULT:
      return Notification::Importance::kDefault;
    case proto::NotificationImportance::HIGH:
      return Notification::Importance::kHigh;
    default:
      return Notification::Importance::kUnspecified;
  }
}

bool HasSupportedActionIdInProto(const proto::Notification& proto) {
  for (const auto& action : proto.actions()) {
    if (action.type() == proto::Action_InputType::Action_InputType_TEXT ||
        action.call_action() ==
            proto::Action_CallAction::Action_CallAction_ANSWER ||
        action.call_action() ==
            proto::Action_CallAction::Action_CallAction_DECLINE ||
        action.call_action() ==
            proto::Action_CallAction::Action_CallAction_HANGUP)
      return true;
  }
  return false;
}

bool IsMonochromeIconEnabled(const proto::Notification& notification_proto) {
  return features::IsPhoneHubMonochromeNotificationIconsEnabled() &&
         notification_proto.origin_app().has_monochrome_icon_mask();
}

Notification CreateInternalNotification(const proto::Notification& proto,
                                        const gfx::Image& color_icon,
                                        const gfx::Image& monochrome_icon,
                                        const gfx::Image& shared_image,
                                        const gfx::Image& contact_image) {
  base::flat_map<Notification::ActionType, int64_t> action_id_map;
  Notification::InteractionBehavior behavior =
      Notification::InteractionBehavior::kNone;
  for (const auto& action : proto.actions()) {
    if (action.type() == proto::Action_InputType::Action_InputType_TEXT) {
      action_id_map[Notification::ActionType::kInlineReply] = action.id();
    } else if (action.type() ==
               proto::Action_InputType::Action_InputType_OPEN) {
      behavior = Notification::InteractionBehavior::kOpenable;
    } else if (action.call_action() ==
               proto::Action_CallAction::Action_CallAction_ANSWER) {
      action_id_map[Notification::ActionType::kAnswer] = action.id();
    } else if (action.call_action() ==
               proto::Action_CallAction::Action_CallAction_DECLINE) {
      action_id_map[Notification::ActionType::kDecline] = action.id();
    } else if (action.call_action() ==
               proto::Action_CallAction::Action_CallAction_HANGUP) {
      action_id_map[Notification::ActionType::kHangup] = action.id();
    }
  }

  Notification::Category category = Notification::Category::kNone;
  switch (proto.category()) {
    case proto::Notification::Category::Notification_Category_UNSPECIFIED:
      category = Notification::Category::kNone;
      break;
    case proto::Notification::Category::Notification_Category_CONVERSATION:
      category = Notification::Category::kConversation;
      break;
    case proto::Notification::Category::Notification_Category_INCOMING_CALL:
      category = Notification::Category::kIncomingCall;
      break;
    case proto::Notification::Category::Notification_Category_ONGOING_CALL:
      category = Notification::Category::kOngoingCall;
      break;
    case proto::Notification::Category::Notification_Category_SCREEN_CALL:
      category = Notification::Category::kScreenCall;
      break;
    case proto::
        Notification_Category_Notification_Category_INT_MIN_SENTINEL_DO_NOT_USE_:  // NOLINT
    case proto::
        Notification_Category_Notification_Category_INT_MAX_SENTINEL_DO_NOT_USE_:  // NOLINT
      PA_LOG(WARNING) << "Notification category is unknown or unspecified.";
      break;
  }

  std::optional<std::u16string> title = std::nullopt;
  if (!proto.title().empty())
    title = base::UTF8ToUTF16(proto.title());

  std::optional<std::u16string> text_content = std::nullopt;
  if (!proto.text_content().empty())
    text_content = base::UTF8ToUTF16(proto.text_content());

  std::optional<gfx::Image> opt_shared_image = std::nullopt;
  if (!shared_image.IsEmpty())
    opt_shared_image = shared_image;

  std::optional<gfx::Image> opt_contact_image = std::nullopt;
  if (!contact_image.IsEmpty())
    opt_contact_image = contact_image;

  bool icon_is_monochrome = IsMonochromeIconEnabled(proto);
  std::optional<SkColor> icon_color =
      icon_is_monochrome ? getMonochromeIconColor(proto, monochrome_icon)
                         : std::nullopt;

  return Notification(
      proto.id(),
      Notification::AppMetadata(
          base::UTF8ToUTF16(proto.origin_app().visible_name()),
          proto.origin_app().package_name(), color_icon, monochrome_icon,
          icon_color, icon_is_monochrome, proto.origin_app().user_id(),
          proto.origin_app().app_streamability_status()),
      base::Time::FromMillisecondsSinceUnixEpoch(proto.epoch_time_millis()),
      GetNotificationImportanceFromProto(proto.importance()), category,
      action_id_map, behavior, title, text_content, opt_shared_image,
      opt_contact_image);
}

}  // namespace

NotificationProcessor::NotificationImages::NotificationImages() = default;

NotificationProcessor::NotificationImages::~NotificationImages() = default;

NotificationProcessor::NotificationImages::NotificationImages(
    const NotificationImages& other) = default;

NotificationProcessor::NotificationImages&
NotificationProcessor::NotificationImages::operator=(
    const NotificationImages& other) = default;

NotificationProcessor::DecodeImageRequestMetadata::DecodeImageRequestMetadata(
    int64_t notification_id,
    NotificationImageField image_field,
    const std::string& data)
    : notification_id(notification_id), image_field(image_field), data(data) {}

NotificationProcessor::NotificationProcessor(
    NotificationManager* notification_manager)
    : NotificationProcessor(notification_manager,
                            std::make_unique<ImageDecoderDelegate>()) {}

NotificationProcessor::NotificationProcessor(
    NotificationManager* notification_manager,
    std::unique_ptr<ImageDecoderDelegate> delegate)
    : notification_manager_(notification_manager),
      delegate_(std::move(delegate)) {}

NotificationProcessor::~NotificationProcessor() {}

void NotificationProcessor::ClearNotificationsAndPendingUpdates() {
  notification_manager_->ClearNotificationsInternal();

  // Clear pending updates that may occur.
  weak_ptr_factory_.InvalidateWeakPtrs();
  pending_notification_requests_ = base::queue<base::OnceClosure>();
  id_to_images_map_.clear();
}

void NotificationProcessor::AddNotifications(
    const std::vector<proto::Notification>& notification_protos) {
  if (notification_protos.empty())
    return;

  std::vector<proto::Notification> processed_notification_protos;
  std::vector<DecodeImageRequestMetadata> decode_image_requests;

  for (const auto& proto : notification_protos) {
    // Only process notifications that are messaging apps with inline-replies
    // or dialer apps with call-style actions.
    if (!HasSupportedActionIdInProto(proto))
      continue;

    processed_notification_protos.emplace_back(proto);

    decode_image_requests.emplace_back(proto.id(),
                                       NotificationImageField::kColorIcon,
                                       proto.origin_app().icon());

    if (IsMonochromeIconEnabled(proto)) {
      decode_image_requests.emplace_back(
          proto.id(), NotificationImageField::kMonochromeIcon,
          proto.origin_app().monochrome_icon_mask());
    } else {
      decode_image_requests.emplace_back(
          proto.id(), NotificationImageField::kMonochromeIcon,
          proto.origin_app().icon());
    }

    if (!proto.shared_image().empty()) {
      decode_image_requests.emplace_back(proto.id(),
                                         NotificationImageField::kSharedImage,
                                         proto.shared_image());
    }

    if (!proto.contact_image().empty()) {
      decode_image_requests.emplace_back(proto.id(),
                                         NotificationImageField::kContactImage,
                                         proto.contact_image());
    }
  }

  if (decode_image_requests.empty()) {
    PA_LOG(INFO) << "Cannot find any image to decode for the notifications";
    return;
  }

  base::RepeatingClosure barrier = base::BarrierClosure(
      decode_image_requests.size(),
      base::BindOnce(&NotificationProcessor::OnAllImagesDecoded,
                     weak_ptr_factory_.GetWeakPtr(),
                     std::move(processed_notification_protos)));

  base::OnceClosure add_request =
      base::BindOnce(&NotificationProcessor::StartDecodingImages,
                     weak_ptr_factory_.GetWeakPtr(),
                     std::move(decode_image_requests), barrier);

  pending_notification_requests_.emplace(std::move(add_request));
  ProcessRequestQueue();
}

void NotificationProcessor::RemoveNotifications(
    const base::flat_set<int64_t>& notification_ids) {
  if (notification_ids.empty())
    return;

  base::flat_set<int64_t> removed_notification_ids;
  for (const int64_t& id : notification_ids) {
    removed_notification_ids.emplace(id);
  }

  base::OnceClosure remove_request = base::BindOnce(
      &NotificationProcessor::RemoveNotificationsAndProcessNextRequest,
      weak_ptr_factory_.GetWeakPtr(), std::move(removed_notification_ids));

  pending_notification_requests_.emplace(std::move(remove_request));
  ProcessRequestQueue();
}

void NotificationProcessor::StartDecodingImages(
    const std::vector<DecodeImageRequestMetadata>& decode_image_requests,
    base::RepeatingClosure done_closure) {
  DCHECK(!decode_image_requests.empty());
  DCHECK(!done_closure.is_null());

  id_to_images_map_.clear();

  for (const auto& request : decode_image_requests) {
    delegate_->PerformImageDecode(
        request.data,
        base::BindOnce(&NotificationProcessor::OnDecodedBitmapReady,
                       weak_ptr_factory_.GetWeakPtr(), request, done_closure));
  }
}

void NotificationProcessor::ImageDecoderDelegate::PerformImageDecode(
    const std::string& data,
    DecodeImageCallback single_image_decoded_closure) {
  data_decoder::DecodeImage(&data_decoder_, base::as_byte_span(data),
                            data_decoder::mojom::ImageCodec::kDefault,
                            /*shrink_to_fit=*/true,
                            data_decoder::kDefaultMaxSizeInBytes,
                            /*desired_image_frame_size=*/gfx::Size(),
                            std::move(single_image_decoded_closure));
}

void NotificationProcessor::OnDecodedBitmapReady(
    const DecodeImageRequestMetadata& request,
    base::OnceClosure done_closure,
    const SkBitmap& decoded_bitmap) {
  gfx::ImageSkia image_skia =
      gfx::ImageSkia::CreateFrom1xBitmap(decoded_bitmap);

  // If |image_skia| is null, indicating that the data decoder failed to decode
  // the image, the image will be empty, and cannot be made thread safe.
  if (!image_skia.isNull())
    image_skia.MakeThreadSafe();

  auto it = id_to_images_map_.find(request.notification_id);
  if (it == id_to_images_map_.end()) {
    it = id_to_images_map_.insert(
        it, std::pair<int64_t, NotificationImages>(request.notification_id,
                                                   NotificationImages()));
  }

  switch (request.image_field) {
    case NotificationImageField::kColorIcon:
      it->second.color_icon = gfx::Image(image_skia);
      break;
    case NotificationImageField::kMonochromeIcon:
      it->second.monochrome_icon_mask = gfx::Image(image_skia);
      break;
    case NotificationImageField::kSharedImage:
      it->second.shared_image = gfx::Image(image_skia);
      break;
    case NotificationImageField::kContactImage:
      it->second.contact_image = gfx::Image(image_skia);
      break;
  }

  std::move(done_closure).Run();
}

void NotificationProcessor::OnAllImagesDecoded(
    std::vector<proto::Notification> notification_protos) {
  base::flat_set<Notification> notifications;
  for (const auto& proto : notification_protos) {
    auto it = id_to_images_map_.find(proto.id());
    if (it == id_to_images_map_.end())
      continue;

    NotificationImages notification_images = it->second;
    notifications.emplace(CreateInternalNotification(
        proto, notification_images.color_icon,
        notification_images.monochrome_icon_mask,
        notification_images.shared_image, notification_images.contact_image));
  }

  AddNotificationsAndProcessNextRequest(notifications);
}

void NotificationProcessor::ProcessRequestQueue() {
  if (pending_notification_requests_.empty())
    return;

  // Processing the latest request has not been completed.
  if (pending_notification_requests_.front().is_null())
    return;

  std::move(pending_notification_requests_.front()).Run();
}

void NotificationProcessor::CompleteRequest() {
  DCHECK(!pending_notification_requests_.empty());
  DCHECK(pending_notification_requests_.front().is_null());
  pending_notification_requests_.pop();
  ProcessRequestQueue();
}

void NotificationProcessor::AddNotificationsAndProcessNextRequest(
    const base::flat_set<Notification>& notifications) {
  notification_manager_->SetNotificationsInternal(notifications);
  CompleteRequest();
}

void NotificationProcessor::RemoveNotificationsAndProcessNextRequest(
    base::flat_set<int64_t> removed_notification_ids) {
  notification_manager_->RemoveNotificationsInternal(removed_notification_ids);
  CompleteRequest();
}

}  // namespace ash::phonehub