// Copyright 2020 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.h"

#include <tuple>

#include "base/base64.h"
#include "base/containers/flat_map.h"
#include "base/logging.h"
#include "base/memory/ref_counted_memory.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "third_party/skia/include/core/SkColor.h"

namespace ash::phonehub {

const char kVisibleAppName[] = "visible_app_name";
const char kPackageName[] = "package_name";
const char kUserId[] = "user_id";
const char kAppStreamabilityStatus[] = "app_streamability_status";
const char kColorIcon[] = "icon";
const char kIconColorR[] = "icon_color_r";
const char kIconColorG[] = "icon_color_g";
const char kIconColorB[] = "icon_color_b";
const char kIconIsMonochrome[] = "icon_is_monochrome";
const char kMonochromeIconMask[] = "monochrome_icon_mask";

Notification::AppMetadata::AppMetadata(
    const std::u16string& visible_app_name,
    const std::string& package_name,
    const gfx::Image& color_icon,
    const std::optional<gfx::Image>& monochrome_icon_mask,
    const std::optional<SkColor> icon_color,
    bool icon_is_monochrome,
    int64_t user_id,
    proto::AppStreamabilityStatus app_streamability_status)
    : visible_app_name(visible_app_name),
      package_name(package_name),
      color_icon(color_icon),
      monochrome_icon_mask(monochrome_icon_mask),
      icon_color(icon_color),
      icon_is_monochrome(icon_is_monochrome),
      user_id(user_id),
      app_streamability_status(app_streamability_status) {}

Notification::AppMetadata::~AppMetadata() = default;

Notification::AppMetadata::AppMetadata(const AppMetadata& other) = default;

Notification::AppMetadata& Notification::AppMetadata::operator=(
    const AppMetadata& other) = default;

bool Notification::AppMetadata::operator==(const AppMetadata& other) const {
  return visible_app_name == other.visible_app_name &&
         package_name == other.package_name && color_icon == other.color_icon &&
         user_id == other.user_id;
}

bool Notification::AppMetadata::operator!=(const AppMetadata& other) const {
  return !(*this == other);
}

base::Value::Dict Notification::AppMetadata::ToValue() const {
  scoped_refptr<base::RefCountedMemory> png_data = color_icon.As1xPNGBytes();
  scoped_refptr<base::RefCountedMemory> monochrome_mask_png_data;

  base::Value::Dict val;
  val.Set(kVisibleAppName, visible_app_name);
  val.Set(kPackageName, package_name);
  val.Set(kUserId, static_cast<double>(user_id));
  val.Set(kColorIcon, base::Base64Encode(*png_data));

  if (monochrome_icon_mask.has_value()) {
    monochrome_mask_png_data = monochrome_icon_mask.value().As1xPNGBytes();
    val.Set(kMonochromeIconMask, base::Base64Encode(*monochrome_mask_png_data));
  }

  val.Set(kIconIsMonochrome, icon_is_monochrome);
  if (icon_color.has_value()) {
    val.Set(kIconColorR, static_cast<int>(SkColorGetR(*icon_color)));
    val.Set(kIconColorG, static_cast<int>(SkColorGetG(*icon_color)));
    val.Set(kIconColorB, static_cast<int>(SkColorGetB(*icon_color)));
  }
  val.Set(kAppStreamabilityStatus, static_cast<int>(app_streamability_status));
  return val;
}

// static
Notification::AppMetadata Notification::AppMetadata::FromValue(
    const base::Value::Dict& value) {
  DCHECK(value.FindString(kVisibleAppName));
  DCHECK(value.FindString(kPackageName));
  DCHECK(value.FindDouble(kUserId));
  DCHECK(value.FindString(kColorIcon));

  if (value.contains(kMonochromeIconMask)) {
    DCHECK(value.FindString(kMonochromeIconMask));
  }

  if (value.contains(kIconIsMonochrome)) {
    DCHECK(value.FindBool(kIconIsMonochrome));
  }
  bool icon_is_monochrome =
      value.FindBoolByDottedPath(kIconIsMonochrome).value_or(false);

  std::optional<SkColor> icon_color = std::nullopt;
  if (value.contains(kIconColorR)) {
    DCHECK(value.FindInt(kIconColorR));
    DCHECK(value.FindInt(kIconColorG));
    DCHECK(value.FindInt(kIconColorB));
    icon_color = SkColorSetRGB(*(value.FindInt(kIconColorR)),
                               *(value.FindInt(kIconColorG)),
                               *(value.FindInt(kIconColorB)));
  }

  const base::Value* visible_app_name_value = value.Find(kVisibleAppName);
  std::u16string visible_app_name_string_value;
  if (visible_app_name_value->is_string()) {
    visible_app_name_string_value =
        base::UTF8ToUTF16(visible_app_name_value->GetString());
  }

  std::string color_icon_str;
  base::Base64Decode(*(value.FindString(kColorIcon)), &color_icon_str);
  gfx::Image decode_color_icon = gfx::Image::CreateFrom1xPNGBytes(
      base::MakeRefCounted<base::RefCountedString>(std::move(color_icon_str)));

  std::optional<gfx::Image> decode_monochrome_icon_mask = std::nullopt;
  std::string monochrome_icon_mask_str;
  if (value.contains(kMonochromeIconMask)) {
    base::Base64Decode(*(value.FindString(kMonochromeIconMask)),
                       &monochrome_icon_mask_str);
    decode_monochrome_icon_mask = gfx::Image::CreateFrom1xPNGBytes(
        base::MakeRefCounted<base::RefCountedString>(
            std::move(monochrome_icon_mask_str)));
  }

  return Notification::AppMetadata(
      visible_app_name_string_value, *(value.FindString(kPackageName)),
      decode_color_icon, decode_monochrome_icon_mask, icon_color,
      icon_is_monochrome, *(value.FindDouble(kUserId)),
      static_cast<proto::AppStreamabilityStatus>(
          value.FindInt(kAppStreamabilityStatus)
              .value_or(static_cast<int>(
                  proto::AppStreamabilityStatus::STREAMABLE))));
}

Notification::Notification(
    int64_t id,
    const AppMetadata& app_metadata,
    const base::Time& timestamp,
    Importance importance,
    Notification::Category category,
    const base::flat_map<Notification::ActionType, int64_t>& action_id_map,
    InteractionBehavior interaction_behavior,
    const std::optional<std::u16string>& title,
    const std::optional<std::u16string>& text_content,
    const std::optional<gfx::Image>& shared_image,
    const std::optional<gfx::Image>& contact_image)
    : id_(id),
      app_metadata_(app_metadata),
      timestamp_(timestamp),
      importance_(importance),
      category_(category),
      action_id_map_(action_id_map),
      interaction_behavior_(interaction_behavior),
      title_(title),
      text_content_(text_content),
      shared_image_(shared_image),
      contact_image_(contact_image) {}

Notification::Notification(const Notification& other) = default;

Notification::~Notification() = default;

bool Notification::operator<(const Notification& other) const {
  return std::tie(timestamp_, id_) < std::tie(other.timestamp_, other.id_);
}

bool Notification::operator==(const Notification& other) const {
  return id_ == other.id_ && app_metadata_ == other.app_metadata_ &&
         timestamp_ == other.timestamp_ && importance_ == other.importance_ &&
         category_ == other.category_ &&
         action_id_map_ == other.action_id_map_ &&
         interaction_behavior_ == other.interaction_behavior_ &&
         title_ == other.title_ && text_content_ == other.text_content_ &&
         shared_image_ == other.shared_image_ &&
         contact_image_ == other.contact_image_;
}

bool Notification::operator!=(const Notification& other) const {
  return !(*this == other);
}

std::ostream& operator<<(std::ostream& stream,
                         const Notification::AppMetadata& app_metadata) {
  stream << "{VisibleAppName: \"" << app_metadata.visible_app_name << "\", "
         << "PackageName: \"" << app_metadata.package_name << "\"}";
  return stream;
}

std::ostream& operator<<(std::ostream& stream,
                         Notification::Importance importance) {
  switch (importance) {
    case Notification::Importance::kUnspecified:
      stream << "[Unspecified]";
      break;
    case Notification::Importance::kNone:
      stream << "[None]";
      break;
    case Notification::Importance::kMin:
      stream << "[Min]";
      break;
    case Notification::Importance::kLow:
      stream << "[Low]";
      break;
    case Notification::Importance::kDefault:
      stream << "[Default]";
      break;
    case Notification::Importance::kHigh:
      stream << "[High]";
      break;
  }
  return stream;
}

std::ostream& operator<<(std::ostream& stream,
                         Notification::InteractionBehavior behavior) {
  switch (behavior) {
    case Notification::InteractionBehavior::kNone:
      stream << "[None]";
      break;
    case Notification::InteractionBehavior::kOpenable:
      stream << "[Openable]";
      break;
  }
  return stream;
}

std::ostream& operator<<(std::ostream& stream,
                         Notification::Category category) {
  switch (category) {
    case Notification::Category::kNone:
      stream << "[None]";
      break;
    case Notification::Category::kConversation:
      stream << "[Conversation]";
      break;
    case Notification::Category::kIncomingCall:
      stream << "[IncomingCall]";
      break;
    case Notification::Category::kOngoingCall:
      stream << "[OngoingCall]";
      break;
    case Notification::Category::kScreenCall:
      stream << "[ScreenCall]";
      break;
  }
  return stream;
}

std::ostream& operator<<(std::ostream& stream,
                         const Notification& notification) {
  stream << "{Id: " << notification.id() << ", "
         << "App: " << notification.app_metadata() << ", "
         << "Timestamp: " << notification.timestamp() << ", "
         << "Importance: " << notification.importance() << ", "
         << "Category: " << notification.category() << ", "
         << "InteractionBehavior: " << notification.interaction_behavior()
         << "}";
  return stream;
}

}  // namespace ash::phonehub