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

#include "third_party/blink/public/common/interest_group/devtools_serialization.h"

#include <cmath>
#include <string_view>
#include <tuple>

#include "base/base64.h"
#include "base/strings/to_string.h"
#include "base/values.h"
#include "third_party/blink/public/common/interest_group/ad_display_size_utils.h"
#include "third_party/blink/public/common/interest_group/auction_config.h"
#include "third_party/blink/public/common/interest_group/interest_group.h"
#include "third_party/blink/public/mojom/interest_group/ad_auction_service.mojom.h"

namespace blink {

namespace {

std::string SerializeIntoKey(const url::Origin& in) {
  return in.Serialize();
}

std::string SerializeIntoKey(const std::string& in) {
  return in;
}

using BuyerReportType = AuctionConfig::NonSharedParams::BuyerReportType;
std::string SerializeIntoKey(BuyerReportType report_type) {
  switch (report_type) {
    case BuyerReportType::kInterestGroupCount:
      return "interestGroupCount";
    case BuyerReportType::kBidCount:
      return "bidCount";
    case BuyerReportType::kTotalGenerateBidLatency:
      return "totalGenerateBidLatency";
    case BuyerReportType::kTotalSignalsFetchLatency:
      return "totalSignalsFetchLatency";
  };
  NOTREACHED();
}

using RealTimeReportingType =
    AuctionConfig::NonSharedParams::RealTimeReportingType;
std::string SerializeIntoValue(RealTimeReportingType report_type) {
  switch (report_type) {
    case RealTimeReportingType::kDefaultLocalReporting:
      return "default-local-reporting";
  };
  NOTREACHED();
}

template <typename T>
base::Value SerializeIntoValue(const T& in) {
  return base::Value(in);
}

// Forward declare for mutual recursion.
template <typename K, typename V>
base::Value SerializeIntoValue(const base::flat_map<K, V>&);

template <typename T>
void SerializeIntoDict(std::string_view field,
                       const T& value,
                       base::Value::Dict& out);

template <typename T>
void SerializeIntoDict(std::string_view field,
                       const std::optional<T>& value,
                       base::Value::Dict& out);

template <typename T>
base::Value SerializeIntoValue(const std::optional<T>& value) {
  if (value.has_value()) {
    return SerializeIntoValue(*value);
  } else {
    return base::Value();
  }
}

template <>
base::Value SerializeIntoValue(const url::Origin& value) {
  return base::Value(value.Serialize());
}

template <>
base::Value SerializeIntoValue(const GURL& value) {
  return base::Value(value.spec());
}

template <>
base::Value SerializeIntoValue(const base::TimeDelta& value) {
  return base::Value(value.InMillisecondsF());
}

template <>
base::Value SerializeIntoValue(const absl::uint128& value) {
  return base::Value(base::ToString(value));
}

template <>
base::Value SerializeIntoValue(
    const blink::AuctionConfig::AdKeywordReplacement& value) {
  base::Value::Dict result;
  result.Set("match", SerializeIntoValue(value.match));
  result.Set("replacement", SerializeIntoValue(value.replacement));
  return base::Value(std::move(result));
}

template <>
base::Value SerializeIntoValue(const double& value) {
  // base::Value, like JSON, can only store finite numbers, so we encode the
  // rest as strings.
  if (std::isfinite(value)) {
    return base::Value(value);
  }
  if (std::isnan(value)) {
    return base::Value("NaN");
  }
  if (std::signbit(value)) {
    return base::Value("-Infinity");
  } else {
    return base::Value("Infinity");
  }
}

template <>
base::Value SerializeIntoValue(
    const AuctionConfig::NonSharedParams::AuctionReportBuyersConfig& value) {
  base::Value::Dict result;
  result.Set("bucket", SerializeIntoValue(value.bucket));
  result.Set("scale", SerializeIntoValue(value.scale));
  return base::Value(std::move(result));
}

template <>
base::Value SerializeIntoValue(const SellerCapabilitiesType& value) {
  base::Value::List result;
  for (blink::SellerCapabilities cap : value) {
    switch (cap) {
      case blink::SellerCapabilities::kInterestGroupCounts:
        result.Append("interest-group-counts");
        break;
      case blink::SellerCapabilities::kLatencyStats:
        result.Append("latency-stats");
        break;
    }
  }
  return base::Value(std::move(result));
}

template <>
base::Value SerializeIntoValue(const base::Uuid& uuid) {
  return base::Value(uuid.AsLowercaseString());
}

template <>
base::Value SerializeIntoValue(
    const blink::AuctionConfig::ServerResponseConfig& server_config) {
  base::Value::Dict result;
  result.Set("requestId", SerializeIntoValue(server_config.request_id));
  return base::Value(std::move(result));
}

template <typename T>
base::Value SerializeIntoValue(const std::vector<T>& values) {
  base::Value::List out;
  for (const T& in_val : values) {
    out.Append(SerializeIntoValue(in_val));
  }
  return base::Value(std::move(out));
}

template <typename T>
base::Value SerializeIntoValue(const AuctionConfig::MaybePromise<T>& promise) {
  base::Value::Dict result;
  result.Set("pending", promise.is_promise());
  if (!promise.is_promise()) {
    result.Set("value", SerializeIntoValue(promise.value()));
  }
  return base::Value(std::move(result));
}

template <>
base::Value SerializeIntoValue(
    const AuctionConfig::NonSharedParams::AuctionReportBuyerDebugModeConfig&
        value) {
  base::Value::Dict result;
  result.Set("enabled", value.is_enabled);
  if (value.debug_key.has_value()) {
    // debug_key is uint64, so it doesn't fit into regular JS numeric types.
    result.Set("debugKey", base::ToString(value.debug_key.value()));
  }
  return base::Value(std::move(result));
}

template <typename K, typename V>
base::Value SerializeIntoValue(const base::flat_map<K, V>& value) {
  base::Value::Dict result;
  for (const auto& kv : value) {
    result.Set(SerializeIntoKey(kv.first), SerializeIntoValue(kv.second));
  }
  return base::Value(std::move(result));
}

// Helper to put the split out all_/'*' value back into a single map.
// Annoyingly we are quite inconsistent about how optional is used. This handles
// both cases for the map; for the value the caller can just use make_optional.
template <typename T>
base::Value::Dict SerializeSplitMapHelper(
    const std::optional<T>& all_value,
    const std::optional<base::flat_map<url::Origin, T>>& per_values) {
  base::Value::Dict result;
  if (all_value.has_value()) {
    result.Set("*", SerializeIntoValue(*all_value));
  }
  if (per_values.has_value()) {
    for (const auto& kv : *per_values) {
      result.Set(SerializeIntoKey(kv.first), SerializeIntoValue(kv.second));
    }
  }

  return result;
}

template <typename T>
base::Value::Dict SerializeSplitMapHelper(
    const std::optional<T>& all_value,
    const base::flat_map<url::Origin, T>& per_values) {
  base::Value::Dict result;
  if (all_value.has_value()) {
    result.Set("*", SerializeIntoValue(*all_value));
  }

  for (const auto& kv : per_values) {
    result.Set(SerializeIntoKey(kv.first), SerializeIntoValue(kv.second));
  }

  return result;
}

template <>
base::Value SerializeIntoValue(const AuctionConfig::BuyerTimeouts& in) {
  return base::Value(
      SerializeSplitMapHelper(in.all_buyers_timeout, in.per_buyer_timeouts));
}

template <>
base::Value SerializeIntoValue(const AuctionConfig::BuyerCurrencies& in) {
  return base::Value(
      SerializeSplitMapHelper(in.all_buyers_currency, in.per_buyer_currencies));
}

template <>
base::Value SerializeIntoValue(const AdCurrency& in) {
  return base::Value(in.currency_code());
}

template <>
base::Value SerializeIntoValue(const AdSize& ad_size) {
  base::Value::Dict result;
  result.Set("width",
             ConvertAdDimensionToString(ad_size.width, ad_size.width_units));
  result.Set("height",
             ConvertAdDimensionToString(ad_size.height, ad_size.height_units));
  return base::Value(std::move(result));
}

template <>
base::Value SerializeIntoValue(
    const blink::mojom::InterestGroup::ExecutionMode& in) {
  switch (in) {
    case blink::mojom::InterestGroup::ExecutionMode::kCompatibilityMode:
      return SerializeIntoValue("compatibility");

    case blink::mojom::InterestGroup::ExecutionMode::kGroupedByOriginMode:
      return SerializeIntoValue("group-by-origin");

    case blink::mojom::InterestGroup::ExecutionMode::kFrozenContext:
      return SerializeIntoValue("frozen-context");
  }
}

template <>
base::Value SerializeIntoValue(const InterestGroup::AdditionalBidKey& in) {
  return base::Value(base::Base64Encode(in));
}

template <>
base::Value SerializeIntoValue(const InterestGroup::Ad& ad) {
  base::Value::Dict result;
  SerializeIntoDict("renderURL", ad.render_url(), result);
  SerializeIntoDict("metadata", ad.metadata, result);
  SerializeIntoDict("buyerReportingId", ad.buyer_reporting_id, result);
  SerializeIntoDict("buyerAndSellerReportingId",
                    ad.buyer_and_seller_reporting_id, result);
  SerializeIntoDict("selectableBuyerAndSellerReportingIds",
                    ad.selectable_buyer_and_seller_reporting_ids, result);
  SerializeIntoDict("adRenderId", ad.ad_render_id, result);
  SerializeIntoDict("allowedReportingOrigins", ad.allowed_reporting_origins,
                    result);
  SerializeIntoDict("creativeScanningMetadata", ad.creative_scanning_metadata,
                    result);
  return base::Value(std::move(result));
}

template <>
base::Value SerializeIntoValue(const AuctionServerRequestFlags& flags) {
  base::Value::List result;
  for (auto flag : flags) {
    switch (flag) {
      case AuctionServerRequestFlagsEnum::kOmitAds:
        result.Append("omit-ads");
        break;

      case AuctionServerRequestFlagsEnum::kIncludeFullAds:
        result.Append("include-full-ads");
        break;
      case AuctionServerRequestFlagsEnum::kOmitUserBiddingSignals:
        result.Append("omit-user-bidding-signals");
        break;
    }
  }
  return base::Value(std::move(result));
}

template <typename T>
void SerializeIntoDict(std::string_view field,
                       const T& value,
                       base::Value::Dict& out) {
  out.Set(field, SerializeIntoValue(value));
}

// Unlike the value serializer this just makes the field not set, rather than
// explicitly null.
template <typename T>
void SerializeIntoDict(std::string_view field,
                       const std::optional<T>& value,
                       base::Value::Dict& out) {
  if (value.has_value()) {
    out.Set(field, SerializeIntoValue(*value));
  }
}

// For use with SerializeSplitMapHelper.
void SerializeIntoDict(std::string_view field,
                       base::Value::Dict value,
                       base::Value::Dict& out) {
  out.Set(field, std::move(value));
}

}  // namespace

base::Value::Dict SerializeAuctionConfigForDevtools(const AuctionConfig& conf) {
  base::Value::Dict result;
  SerializeIntoDict("seller", conf.seller, result);
  SerializeIntoDict("serverResponse", conf.server_response, result);
  SerializeIntoDict("decisionLogicURL", conf.decision_logic_url, result);
  SerializeIntoDict("trustedScoringSignalsURL",
                    conf.trusted_scoring_signals_url, result);
  SerializeIntoDict("deprecatedRenderURLReplacements",
                    conf.non_shared_params.deprecated_render_url_replacements,
                    result);
  SerializeIntoDict("interestGroupBuyers",
                    conf.non_shared_params.interest_group_buyers, result);
  SerializeIntoDict("auctionSignals", conf.non_shared_params.auction_signals,
                    result);
  SerializeIntoDict("sellerSignals", conf.non_shared_params.seller_signals,
                    result);
  SerializeIntoDict("sellerTKVSignals",
                    conf.non_shared_params.seller_tkv_signals, result);
  SerializeIntoDict("sellerTimeout", conf.non_shared_params.seller_timeout,
                    result);
  SerializeIntoDict("perBuyerSignals", conf.non_shared_params.per_buyer_signals,
                    result);
  SerializeIntoDict("perBuyerTKVSignals",
                    conf.non_shared_params.per_buyer_tkv_signals, result);
  SerializeIntoDict("perBuyerTimeouts", conf.non_shared_params.buyer_timeouts,
                    result);
  SerializeIntoDict("perBuyerCumulativeTimeouts",
                    conf.non_shared_params.buyer_cumulative_timeouts, result);
  SerializeIntoDict("reportingTimeout",
                    conf.non_shared_params.reporting_timeout, result);
  SerializeIntoDict("sellerCurrency", conf.non_shared_params.seller_currency,
                    result);
  SerializeIntoDict("perBuyerCurrencies",
                    conf.non_shared_params.buyer_currencies, result);
  SerializeIntoDict(
      "perBuyerGroupLimits",
      SerializeSplitMapHelper(
          std::make_optional(conf.non_shared_params.all_buyers_group_limit),
          conf.non_shared_params.per_buyer_group_limits),
      result);
  SerializeIntoDict("perBuyerPrioritySignals",
                    SerializeSplitMapHelper(
                        conf.non_shared_params.all_buyers_priority_signals,
                        conf.non_shared_params.per_buyer_priority_signals),
                    result);
  SerializeIntoDict("auctionReportBuyerKeys",
                    conf.non_shared_params.auction_report_buyer_keys, result);
  SerializeIntoDict("auctionReportBuyers",
                    conf.non_shared_params.auction_report_buyers, result);
  SerializeIntoDict("requiredSellerCapabilities",
                    conf.non_shared_params.required_seller_capabilities,
                    result);
  SerializeIntoDict(
      "auctionReportBuyerDebugModeConfig",
      conf.non_shared_params.auction_report_buyer_debug_mode_config, result);
  SerializeIntoDict("requestedSize", conf.non_shared_params.requested_size,
                    result);
  SerializeIntoDict("allSlotsRequestedSizes",
                    conf.non_shared_params.all_slots_requested_sizes, result);
  SerializeIntoDict(
      "perBuyerMultiBidLimit",
      SerializeSplitMapHelper(
          std::make_optional(conf.non_shared_params.all_buyers_multi_bid_limit),
          conf.non_shared_params.per_buyer_multi_bid_limits),
      result);
  SerializeIntoDict("auctionNonce", conf.non_shared_params.auction_nonce,
                    result);
  SerializeIntoDict("sellerRealTimeReportingType",
                    conf.non_shared_params.seller_real_time_reporting_type,
                    result);
  SerializeIntoDict("perBuyerRealTimeReportingTypes",
                    conf.non_shared_params.per_buyer_real_time_reporting_types,
                    result);

  SerializeIntoDict("sendCreativeScanningMetadata",
                    conf.send_creative_scanning_metadata, result);

  // For component auctions, we only serialize the seller names to give a
  // quick overview, since they'll get their own events.
  if (!conf.non_shared_params.component_auctions.empty()) {
    base::Value::List component_auctions;
    for (const auto& child_config : conf.non_shared_params.component_auctions) {
      component_auctions.Append(child_config.seller.Serialize());
    }
    result.Set("componentAuctions", std::move(component_auctions));
  }

  SerializeIntoDict(
      "maxTrustedScoringSignalsURLLength",
      conf.non_shared_params.max_trusted_scoring_signals_url_length, result);

  SerializeIntoDict("trustedScoringSignalsCoordinator",
                    conf.non_shared_params.trusted_scoring_signals_coordinator,
                    result);

  SerializeIntoDict("executionMode", conf.non_shared_params.execution_mode,
                    result);

  // direct_from_seller_signals --- skipped.
  SerializeIntoDict("expectsDirectFromSellerSignalsHeaderAdSlot",
                    conf.expects_direct_from_seller_signals_header_ad_slot,
                    result);
  SerializeIntoDict("sellerExperimentGroupId", conf.seller_experiment_group_id,
                    result);
  SerializeIntoDict(
      "perBuyerExperimentGroupIds",
      SerializeSplitMapHelper(conf.all_buyer_experiment_group_id,
                              conf.per_buyer_experiment_group_ids),
      result);
  SerializeIntoDict("expectsAdditionalBids", conf.expects_additional_bids,
                    result);
  SerializeIntoDict("aggregationCoordinatorOrigin",
                    conf.aggregation_coordinator_origin, result);

  return result;
}

base::Value::Dict SerializeInterestGroupForDevtools(const InterestGroup& ig) {
  base::Value::Dict result;
  // This used to have its own type in Devtools protocol
  // ("InterestGroupDetails"); the fields that existed there are named to match;
  // otherwise the WebIDL is generally followed.
  SerializeIntoDict("expirationTime", ig.expiry.InSecondsFSinceUnixEpoch(),
                    result);
  SerializeIntoDict("ownerOrigin", ig.owner, result);
  SerializeIntoDict("name", ig.name, result);

  SerializeIntoDict("priority", ig.priority, result);
  SerializeIntoDict("enableBiddingSignalsPrioritization",
                    ig.enable_bidding_signals_prioritization, result);
  SerializeIntoDict("priorityVector", ig.priority_vector, result);
  SerializeIntoDict("prioritySignalsOverrides", ig.priority_signals_overrides,
                    result);

  SerializeIntoDict(
      "sellerCapabilities",
      SerializeSplitMapHelper(std::make_optional(ig.all_sellers_capabilities),
                              ig.seller_capabilities),
      result);
  SerializeIntoDict("executionMode", ig.execution_mode, result);

  SerializeIntoDict("biddingLogicURL", ig.bidding_url, result);
  SerializeIntoDict("biddingWasmHelperURL", ig.bidding_wasm_helper_url, result);
  SerializeIntoDict("updateURL", ig.update_url, result);
  SerializeIntoDict("trustedBiddingSignalsURL", ig.trusted_bidding_signals_url,
                    result);
  SerializeIntoDict("trustedBiddingSignalsKeys",
                    ig.trusted_bidding_signals_keys, result);

  SerializeIntoDict("trustedBiddingSignalsSlotSizeMode",
                    InterestGroup::TrustedBiddingSignalsSlotSizeModeToString(
                        ig.trusted_bidding_signals_slot_size_mode),
                    result);
  SerializeIntoDict("maxTrustedBiddingSignalsURLLength",
                    ig.max_trusted_bidding_signals_url_length, result);
  SerializeIntoDict("trustedBiddingSignalsCoordinator",
                    ig.trusted_bidding_signals_coordinator, result);
  SerializeIntoDict("viewAndClickCountsProviders",
                    ig.view_and_click_counts_providers, result);
  SerializeIntoDict("userBiddingSignals", ig.user_bidding_signals, result);
  SerializeIntoDict("ads", ig.ads, result);
  SerializeIntoDict("adComponents", ig.ad_components, result);
  SerializeIntoDict("adSizes", ig.ad_sizes, result);
  SerializeIntoDict("sizeGroups", ig.size_groups, result);
  SerializeIntoDict("auctionServerRequestFlags",
                    ig.auction_server_request_flags, result);
  SerializeIntoDict("additionalBidKey", ig.additional_bid_key, result);
  SerializeIntoDict("aggregationCoordinatorOrigin",
                    ig.aggregation_coordinator_origin, result);

  return result;
}

}  // namespace blink