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

#include "chrome/browser/ui/commerce/price_tracking_page_action_controller.h"

#include "base/check_is_test.h"
#include "base/metrics/histogram_functions.h"
#include "base/strings/string_number_conversions.h"
#include "components/commerce/core/price_tracking_utils.h"
#include "components/commerce/core/shopping_service.h"
#include "components/feature_engagement/public/tracker.h"
#include "components/image_fetcher/core/image_fetcher.h"

namespace commerce {

namespace {
constexpr net::NetworkTrafficAnnotationTag kShoppingListTrafficAnnotation =
    net::DefineNetworkTrafficAnnotation("shopping_list_ui_image_fetcher",
                                        R"(
        semantics {
          sender: "Product image fetcher for the shopping list feature."
          description:
            "Retrieves the image for a product that is displayed on the active "
            "web page. This will be shown to the user as part of the "
            "bookmarking or price tracking action."
          trigger:
            "On navigation, if the URL of the page is determined to be a "
            "product that can be price tracked, we will attempt to fetch the "
            "image for it."
          user_data {
            type: NONE
          }
          data: "No user data."
          internal {
            contacts {
                email: "chrome-shopping@google.com"
            }
          }
          destination: GOOGLE_OWNED_SERVICE
          last_reviewed: "2024-01-11"
        }
        policy {
          cookies_allowed: NO
          setting:
            "This fetch is enabled for any user with the 'Shopping List' "
            "feature enabled."
          chrome_policy {
            ShoppingListEnabled {
              policy_options {mode: MANDATORY}
              ShoppingListEnabled: false
            }
          }
        })");

constexpr char kImageFetcherUmaClient[] = "ShoppingList";

// The minimum price that the price tracking UI always wants to expand at.
constexpr int64_t kAlwaysExpandChipPriceMicros = 100000000L;

}  // namespace

PriceTrackingPageActionController::PriceTrackingPageActionController(
    base::RepeatingCallback<void()> notify_callback,
    ShoppingService* shopping_service,
    image_fetcher::ImageFetcher* image_fetcher,
    feature_engagement::Tracker* tracker)
    : CommercePageActionController(std::move(notify_callback)),
      shopping_service_(shopping_service),
      image_fetcher_(image_fetcher),
      tracker_(tracker) {
  if (shopping_service_) {
    scoped_observation_.Observe(shopping_service_);
    shopping_service_->WaitForReady(base::BindOnce(
        [](base::WeakPtr<PriceTrackingPageActionController> controller,
           ShoppingService* service) {
          if (!controller || !service) {
            return;
          }
          if (service->IsShoppingListEligible()) {
            // Fetching the image may have been blocked by the eligibility
            // check, retry.
            controller->MaybeDoProductImageFetch(
                controller->product_info_for_page_);
            controller->NotifyHost();
          }
        },
        weak_ptr_factory_.GetWeakPtr()));
  } else {
    CHECK_IS_TEST();
  }
}

PriceTrackingPageActionController::~PriceTrackingPageActionController() {
  // Recording this in the destructor corresponds to the tab being closed or the
  // browser shutting down.
  MaybeRecordPriceTrackingIconMetrics(/*from_icon_use=*/false);
}

std::optional<bool>
PriceTrackingPageActionController::ShouldShowForNavigation() {
  // If the user isn't eligible for the feature, don't block.
  if (!shopping_service_ || !shopping_service_->IsShoppingListEligible()) {
    return false;
  }

  // If we got a response from the shopping service but the response was empty,
  // we don't need to wait for the image or subscription status.
  if (got_product_response_for_page_ && !product_info_for_page_.has_value()) {
    return false;
  }

  // If the page is determined to be a product page, we're "undecided" until we
  // can show the current subscription state and have an image for the UI.
  if (!got_initial_subscription_status_for_page_ ||
      !got_image_response_for_page_) {
    return std::nullopt;
  }

  return !last_fetched_image_.IsEmpty();
}

bool PriceTrackingPageActionController::WantsExpandedUi() {
  if (!product_info_for_page_.has_value()) {
    return false;
  }
  CommerceSubscription sub(
      SubscriptionType::kPriceTrack, IdentifierType::kProductClusterId,
      base::NumberToString(product_info_for_page_->product_cluster_id.value()),
      ManagementType::kUserManaged);
  bool already_subscribed = shopping_service_->IsSubscribedFromCache(sub);

  // Don't expand the chip if the user is already subscribed to the product.
  if (!already_subscribed) {
    if (tracker_ &&
        tracker_->ShouldTriggerHelpUI(
            feature_engagement::kIPHPriceTrackingPageActionIconLabelFeature)) {
      tracker_->Dismissed(
          feature_engagement::kIPHPriceTrackingPageActionIconLabelFeature);
      expanded_ui_for_page_ = true;
      return true;
    }

    // If none of the above cases expanded a chip, expand the price tracking
    // chip if the product price is > $100.
    if (product_info_for_page_->amount_micros > kAlwaysExpandChipPriceMicros &&
        product_info_for_page_->product_cluster_id.has_value()) {
      expanded_ui_for_page_ = true;
      return true;
    }
  }

  return false;
}

void PriceTrackingPageActionController::ResetForNewNavigation(const GURL& url) {
  if (!shopping_service_->IsShoppingListEligible()) {
    return;
  }

  // The page action icon may not have been used for the last page load. If
  // that's the case, make sure we record it.
  MaybeRecordPriceTrackingIconMetrics(/*from_icon_use=*/false);

  // Cancel any pending callbacks.
  weak_ptr_factory_.InvalidateWeakPtrs();

  is_cluster_id_tracked_by_user_ = false;
  last_fetched_image_ = gfx::Image();
  last_fetched_image_url_ = GURL();
  current_url_ = url;
  got_product_response_for_page_ = false;
  got_image_response_for_page_ = false;
  got_initial_subscription_status_for_page_ = false;
  expanded_ui_for_page_ = false;
  icon_use_recorded_for_page_ = false;

  // Initiate an update for the icon on navigation since we may not have product
  // info.
  NotifyHost();

  shopping_service_->GetProductInfoForUrl(
      url, base::BindOnce(
               &PriceTrackingPageActionController::HandleProductInfoResponse,
               weak_ptr_factory_.GetWeakPtr()));
}

void PriceTrackingPageActionController::OnIconClicked() {
  MaybeRecordPriceTrackingIconMetrics(/*from_icon_use=*/true);
}

void PriceTrackingPageActionController::MaybeRecordPriceTrackingIconMetrics(
    bool from_icon_use) {
  // Ignore cases where these is no cluster ID or the metric was already
  // recorded for the page.
  if (!cluster_id_for_page_.has_value() || icon_use_recorded_for_page_) {
    return;
  }

  icon_use_recorded_for_page_ = true;

  // Ignore any instances where the product is already tracked. This will not
  // stop cases where the icon is being used to newly track a product since
  // this logic will run prior to subscriptions updating.
  if (is_cluster_id_tracked_by_user_) {
    return;
  }

  std::string histogram_name = "Commerce.PriceTracking.IconInteractionState";

  // Clicking the icon for a product that is already tracked does not
  // immediately untrack the product. If we made it this far, we can assume the
  // interaction was to track a product, otherwise we would have been blocked
  // above.
  if (from_icon_use) {
    if (expanded_ui_for_page_) {
      base::UmaHistogramEnumeration(
          histogram_name, PageActionIconInteractionState::kClickedExpanded);
    } else {
      base::UmaHistogramEnumeration(histogram_name,
                                    PageActionIconInteractionState::kClicked);
    }
  } else {
    if (expanded_ui_for_page_) {
      base::UmaHistogramEnumeration(
          histogram_name, PageActionIconInteractionState::kNotClickedExpanded);
    } else {
      base::UmaHistogramEnumeration(
          histogram_name, PageActionIconInteractionState::kNotClicked);
    }
  }
}

void PriceTrackingPageActionController::HandleProductInfoResponse(
    const GURL& url,
    const std::optional<const ProductInfo>& info) {
  if (url != current_url_ || !info.has_value()) {
    got_product_response_for_page_ = true;
    NotifyHost();
    return;
  }

  product_info_for_page_ = info;
  got_product_response_for_page_ = true;

  if (shopping_service_->IsShoppingListEligible() && CanTrackPrice(info) &&
      !info->image_url.is_empty()) {
    cluster_id_for_page_.emplace(info->product_cluster_id.value());
    UpdatePriceTrackingStateFromSubscriptions();

    MaybeDoProductImageFetch(info);
  }
}

void PriceTrackingPageActionController::MaybeDoProductImageFetch(
    const std::optional<ProductInfo>& info) {
  if (!shopping_service_->IsShoppingListEligible() || !CanTrackPrice(info) ||
      info->image_url.is_empty() || !this->last_fetched_image_.IsEmpty()) {
    return;
  }

  // TODO(crbug.com/40863328): Delay this fetch by possibly waiting until page
  // load has
  //                finished.
  image_fetcher_->FetchImage(
      info.value().image_url,
      base::BindOnce(
          &PriceTrackingPageActionController::HandleImageFetcherResponse,
          weak_ptr_factory_.GetWeakPtr(), info.value().image_url),
      image_fetcher::ImageFetcherParams(kShoppingListTrafficAnnotation,
                                        kImageFetcherUmaClient));
}

void PriceTrackingPageActionController::
    UpdatePriceTrackingStateFromSubscriptions() {
  if (!cluster_id_for_page_.has_value()) {
    return;
  }

  shopping_service_->IsSubscribed(
      BuildUserSubscriptionForClusterId(cluster_id_for_page_.value()),
      base::BindOnce(
          [](base::WeakPtr<PriceTrackingPageActionController> controller,
             bool is_tracked) {
            if (!controller) {
              return;
            }

            controller->is_cluster_id_tracked_by_user_ = is_tracked;
            controller->got_initial_subscription_status_for_page_ = true;
            controller->NotifyHost();
          },
          weak_ptr_factory_.GetWeakPtr()));
}

void PriceTrackingPageActionController::OnSubscribe(
    const CommerceSubscription& subscription,
    bool succeeded) {
  HandleSubscriptionChange(subscription);
}

void PriceTrackingPageActionController::OnUnsubscribe(
    const CommerceSubscription& subscription,
    bool succeeded) {
  HandleSubscriptionChange(subscription);
}

void PriceTrackingPageActionController::HandleSubscriptionChange(
    const CommerceSubscription& sub) {
  if (sub.id_type == IdentifierType::kProductClusterId &&
      sub.id == base::NumberToString(
                    cluster_id_for_page_.value_or(kInvalidSubscriptionId))) {
    UpdatePriceTrackingStateFromSubscriptions();
    NotifyHost();
  }
}

void PriceTrackingPageActionController::HandleImageFetcherResponse(
    const GURL image_url,
    const gfx::Image& image,
    const image_fetcher::RequestMetadata& request_metadata) {
  got_image_response_for_page_ = true;

  if (!image.IsEmpty()) {
    last_fetched_image_url_ = image_url;
    last_fetched_image_ = image;
  }

  NotifyHost();
}

const gfx::Image& PriceTrackingPageActionController::GetLastFetchedImage() {
  return last_fetched_image_;
}

const GURL& PriceTrackingPageActionController::GetLastFetchedImageUrl() {
  return last_fetched_image_url_;
}

bool PriceTrackingPageActionController::IsPriceTrackingCurrentProduct() {
  return is_cluster_id_tracked_by_user_;
}

void PriceTrackingPageActionController::SetImageFetcherForTesting(
    image_fetcher::ImageFetcher* image_fetcher) {
  image_fetcher_ = image_fetcher;
}

}  // namespace commerce