// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

#include "assertion/validator.h"

#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <utility>
#include <vector>

#include "absl/base/no_destructor.h"
#include "absl/container/flat_hash_map.h"
#include "absl/container/flat_hash_set.h"
#include "absl/log/log.h"
#include "absl/status/statusor.h"
#include "absl/strings/match.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "assertion/actions_assertion_validator.h"
#include "assertion/assertion_parser.h"
#include "assertion/hashed_uri_validator.h"
#include "assertion/references_validator.h"
#include "constants/ingredient_relationships.h"
#include "constants/labels.h"
#include "constants/status_codes.h"
#include "google/protobuf/repeated_ptr_field.h"
#include "jumbf/box.h"
#include "jumbf/uri.h"
#include "proto/actions_assertion.pb.h"
#include "proto/assertion.pb.h"
#include "proto/generator_info.pb.h"
#include "proto/hashed_uri.pb.h"
#include "proto/ingredient_assertion.pb.h"
#include "proto/manifest.pb.h"
#include "validator/tracker.h"

namespace credentio {
namespace {

using ::jumbf::BinaryDataBox;
using ::jumbf::CborBox;
using ::jumbf::EmbeddedFileDescriptionBox;
using ::jumbf::JsonBox;
using ::jumbf::SuperBox;

constexpr absl::string_view kUnknown = "c2pa.unknown";

enum ManifestType {
  kStandardManifest,
  kUpdateManifest,
};

absl::string_view Basename(absl::string_view path) {
  const size_t pos = path.find_last_of('/');
  if (pos == absl::string_view::npos) {
    return path;
  }
  return path.substr(pos + 1);
}

template <typename ActionsT>
bool ValidateActions(const ActionsT& actions, absl::string_view assertion_url,
                     ValidationTracker& validation_tracker) {
  for (const auto& action : actions.actions()) {
    if (action.action() == kUnknown) {
      validation_tracker.RecordFailure(
          FailureStatusCode::kGoogleAssertionActionUnknownAction,
          {.url = assertion_url});
      return false;
    }
  }
  return true;
}

bool HasSuccesses(const ValidationStatusSet& validation) {
  return !validation.successes().empty();
}

bool HasFailures(const ValidationStatusSet& validation) {
  return !validation.failures().empty();
}

bool IsHardBindingSuccessCode(absl::string_view code) {
  static const absl::NoDestructor<absl::flat_hash_set<std::string>>
      kHardBindingSuccessCodes({
          absl::StrCat(SuccessStatusCode::kAssertionBmffHashMatch),
          absl::StrCat(SuccessStatusCode::kAssertionBoxesHashMatch),
          absl::StrCat(SuccessStatusCode::kAssertionCollectionHashMatch),
          absl::StrCat(SuccessStatusCode::kAssertionDataHashMatch),
      });
  return kHardBindingSuccessCodes->contains(code);
}

bool HasHardBindingSuccess(const ValidationStatusSet& validation) {
  return std::any_of(validation.successes().begin(),
                     validation.successes().end(), [](const auto& status) {
                       return IsHardBindingSuccessCode(status.code());
                     });
}

bool ValidateIngredientAssertionValidationResults(
    const IngredientAssertionV3& ingredient, absl::string_view assertion_url,
    ManifestType manifest_type, ValidationTracker& validation_tracker) {
  if (!ingredient.has_active_manifest()) {
    // No validation results expected.
    return true;
  }
  const ValidationStatusSet& ingredient_validation =
      ingredient.validation_results().active_manifest();
  if (!HasFailures(ingredient_validation)) {
    switch (manifest_type) {
      case kStandardManifest:
        if (!HasHardBindingSuccess(ingredient_validation)) {
          validation_tracker.RecordFailure(
              FailureStatusCode::kAssertionIngredientMalformed,
              {.url = assertion_url,
               .explanation = "no hard binding check recorded"});
          return false;
        }
        break;
      case kUpdateManifest:
        if (!HasSuccesses(ingredient_validation)) {
          validation_tracker.RecordFailure(
              FailureStatusCode::kAssertionIngredientMalformed,
              {.url = assertion_url,
               .explanation = "no validation successes or failures recorded"});
          return false;
        }
        break;
    }
  }
  return true;
}

bool IsValidIngredientRelationship(absl::string_view relationship) {
  return relationship == kIngredientRelationshipParentOf ||
         relationship == kIngredientRelationshipComponentOf ||
         relationship == kIngredientRelationshipInputTo;
}

bool ValidateIngredientAssertion(const IngredientAssertionV3& ingredient,
                                 absl::string_view assertion_url,
                                 ManifestType manifest_type,
                                 ValidationTracker& validation_tracker) {
  if (ingredient.has_active_manifest() &&
      !ingredient.digital_source_type().empty()) {
    validation_tracker.RecordFailure(
        FailureStatusCode::kAssertionIngredientMalformed,
        {.url = assertion_url,
         .explanation = "Ingredient assertion must not contain both "
                        "activeManifest and digitalSourceType"});
    return false;
  }
  // Note that while
  // https://spec.c2pa.org/specifications/specifications/2.1/specs/C2PA_Specification.html#_performing_explicit_validation
  // only calls for relationship validation on v3 ingredient assertions, this
  // was subsequently corrected for C2PA 2.2 in
  // https://github.com/c2pa-org/specs-core/pull/1513.
  if (ingredient.relationship().empty()) {
    validation_tracker.RecordFailure(
        FailureStatusCode::kAssertionIngredientMalformed,
        {.url = assertion_url,
         .explanation = "Missing ingredient relationship"});
    return false;
  }
  if (!IsValidIngredientRelationship(ingredient.relationship())) {
    validation_tracker.RecordFailure(
        FailureStatusCode::kAssertionIngredientMalformed,
        {.url = assertion_url,
         .explanation = "Unrecognized ingredient relationship"});
    return false;
  }
  return ValidateIngredientAssertionValidationResults(
      ingredient, assertion_url, manifest_type, validation_tracker);
}

bool ActionAllowedInUpdateManifest(absl::string_view action) {
  return action == "c2pa.edited.metadata" || action == "c2pa.opened" ||
         action == "c2pa.published" || action == "c2pa.redacted";
}

struct AssertionCounter {
  uint32_t hard_bindings = 0;
  uint32_t ingredients = 0;
  uint32_t thumbnails = 0;
  std::string action_disallowed_in_update;
  absl::flat_hash_map<std::string, uint32_t> ingredient_relationships;
  bool has_soft_binding = false;
  bool has_watermarked_bound_action = false;

  void RecordAction(absl::string_view action) {
    if (action_disallowed_in_update.empty() &&
        !ActionAllowedInUpdateManifest(action)) {
      action_disallowed_in_update = action;
    }
    if (action == "c2pa.watermarked.bound" || action == "c2pa.watermarked") {
      has_watermarked_bound_action = true;
    }
  }

  void Add(const Assertion& assertion) {
    if (assertion.has_soft_binding()) {
      has_soft_binding = true;
    }
    if (assertion.has_data_hash() || assertion.has_bmff_based_hash() ||
        assertion.has_boxes_hash() || assertion.has_collection_data_hash()) {
      if (!absl::StrContains(assertion.label(), ".part")) {
        // Only count the full asset hard binding.
        ++hard_bindings;
      }
    }
    for (const auto& action : assertion.actions().actions()) {
      RecordAction(action.action());
    }
    for (const auto& action : assertion.actions_v1().actions()) {
      RecordAction(action.action());
    }
    if (assertion.has_ingredient_v3()) {
      ++ingredients;
      ++ingredient_relationships[assertion.ingredient_v3().relationship()];
    }
    if (assertion.has_claim_thumbnail() ||
        assertion.has_ingredient_thumbnail()) {
      ++thumbnails;
    }
  }

  // See:
  // https://spec.c2pa.org/specifications/specifications/2.2/specs/C2PA_Specification.html#_validate_the_assertions
  void ValidateStandardManifestCounts(absl::string_view claim_box_url,
                                      ValidationTracker& validation_tracker) {
    if (hard_bindings == 0) {
      validation_tracker.RecordFailure(
          FailureStatusCode::kClaimHardBindingsMissing,
          {.url = claim_box_url,
           .explanation = "Standard manifest must contain one hard binding."});
    } else if (hard_bindings > 1) {
      validation_tracker.RecordFailure(
          FailureStatusCode::kAssertionMultipleHardBindings,
          {.url = kAssertionStoreLabel,
           .explanation = "Standard manifest must not contain more than one "
                          "hard binding."});
    }
    if (ingredient_relationships[kIngredientRelationshipParentOf] > 1) {
      validation_tracker.RecordFailure(
          FailureStatusCode::kManifestMultipleParents,
          {.url = claim_box_url,
           .explanation = "Standard manifest must contain at most one "
                          "ingredient with parentOf relationship."});
    }
  }

  // See:
  // https://spec.c2pa.org/specifications/specifications/2.2/specs/C2PA_Specification.html#_validate_the_assertions
  void ValidateUpdateManifestCounts(absl::string_view claim_box_url,
                                    ValidationTracker& validation_tracker) {
    if (hard_bindings != 0) {
      validation_tracker.RecordFailure(
          FailureStatusCode::kManifestUpdateInvalid,
          {.url = claim_box_url,
           .explanation = "Update manifest must not contain hard bindings."});
    }
    if (!action_disallowed_in_update.empty()) {
      validation_tracker.RecordFailure(
          FailureStatusCode::kManifestUpdateInvalid,
          {.url = claim_box_url,
           .explanation =
               absl::StrCat("Update manifest contains disallowed action: ",
                            action_disallowed_in_update)});
    }
    if (ingredients != 1) {
      validation_tracker.RecordFailure(
          FailureStatusCode::kManifestUpdateWrongParents,
          {.url = claim_box_url,
           .explanation = absl::StrCat(
               "Update manifest must contain exactly one ingredient; found ",
               ingredients)});
    } else if (ingredient_relationships[kIngredientRelationshipParentOf] != 1) {
      validation_tracker.RecordFailure(
          FailureStatusCode::kManifestUpdateWrongParents,
          {.url = claim_box_url,
           .explanation =
               "Update manifest ingredient relationship must be parentOf."});
    }
  }

  void ValidateSoftBinding(absl::string_view claim_box_url,
                           ValidationTracker& validation_tracker) {
    if (has_watermarked_bound_action && !has_soft_binding) {
      validation_tracker.RecordFailure(
          FailureStatusCode::kAssertionActionSoftBindingMissing,
          {.url = claim_box_url,
           .explanation = "c2pa.watermarked.bound action requires a "
                          "c2pa.soft-binding assertion"});
    }
  }
};

void ValidateCborAssertion(
    absl::string_view label, absl::string_view payload,
    ManifestType manifest_type, const AssertionParser& assertion_parser,
    const ReferencesValidator& references_validator,
    google::protobuf::RepeatedPtrField<Assertion>* assertions_out,
    ValidationTracker& validation_tracker,
    AssertionCounter& assertion_counter) {
  std::optional<Assertion> assertion_proto =
      assertion_parser.ParseCbor(label, payload, validation_tracker);
  if (!assertion_proto.has_value()) {
    return;
  }
  assertion_counter.Add(*assertion_proto);
  if (!references_validator.Validate(*assertion_proto)) {
    return;
  }
  const std::string assertion_url = absl::StrCat(
      kAssertionStoreLabel, kManifestLabelDelimiter, assertion_proto->label());
  switch (assertion_proto->assertion_case()) {
    case Assertion::kActionsV1:
      if (!ValidateActions(assertion_proto->actions_v1(), assertion_url,
                           validation_tracker)) {
        return;
      }
      break;
    case Assertion::kActions:
      if (!ValidateActions(assertion_proto->actions(), assertion_url,
                           validation_tracker)) {
        return;
      }
      break;
    case Assertion::kIngredientV3:
      if (!ValidateIngredientAssertion(assertion_proto->ingredient_v3(),
                                       assertion_url, manifest_type,
                                       validation_tracker)) {
        return;
      }
      break;
    default:
      break;
  }
  assertions_out->Add(*std::move(assertion_proto));
}

void ValidateAssertionContents(
    const SuperBox* assertion_box, ManifestType manifest_type,
    const AssertionParser& assertion_parser,
    const ReferencesValidator& references_validator,
    google::protobuf::RepeatedPtrField<Assertion>* assertions_out,
    ValidationTracker& validation_tracker,
    AssertionCounter& assertion_counter) {
  // CBOR assertion.
  if (assertion_box->contents.size() == 1 &&
      assertion_box->contents[0].Holds<CborBox>()) {
    ValidateCborAssertion(assertion_box->description.label.value_or(""),
                          assertion_box->contents[0].Get<CborBox>().payload,
                          manifest_type, assertion_parser, references_validator,
                          assertions_out, validation_tracker,
                          assertion_counter);
    return;
  }
  // Thumbnail assertion (EmbeddedFileDescriptionBox + BinaryDataBox).
  if (assertion_box->contents.size() == 2 &&
      assertion_box->contents[0].Holds<EmbeddedFileDescriptionBox>() &&
      assertion_box->contents[1].Holds<BinaryDataBox>()) {
    std::optional<Assertion> assertion_proto = assertion_parser.ParseThumbnail(
        assertion_box->description.label.value_or(""),
        assertion_box->contents[0].Get<EmbeddedFileDescriptionBox>().media_type,
        assertion_box->contents[1].Get<BinaryDataBox>().payload,
        assertion_box->contents[0].Get<EmbeddedFileDescriptionBox>().file_name,
        validation_tracker);
    if (assertion_proto.has_value()) {
      assertions_out->Add(*std::move(assertion_proto));
    }
    return;
  }
  // JSON-LD assertion (e.g., c2pa.metadata).
  if (assertion_box->contents.size() == 1 &&
      assertion_box->contents[0].Holds<JsonBox>()) {
    std::optional<Assertion> assertion_proto = assertion_parser.ParseMetadata(
        assertion_box->description.label.value_or(""),
        assertion_box->contents[0].Get<JsonBox>().payload, validation_tracker);
    if (assertion_proto.has_value()) {
      assertions_out->Add(*std::move(assertion_proto));
    }
    return;
  }

  // Ignore other types of assertions.
}

bool ContainsAllZeroBytes(absl::string_view data) {
  return std::all_of(data.begin(), data.end(), [](char c) { return c == 0; });
}

bool ContainsAllZeroBytes(const jumbf::ContentBox& content) {
  if (content.Holds<CborBox>()) {
    return ContainsAllZeroBytes(content.Get<CborBox>().payload);
  }
  if (content.Holds<JsonBox>()) {
    return ContainsAllZeroBytes(content.Get<JsonBox>().payload);
  }
  if (content.Holds<BinaryDataBox>()) {
    return ContainsAllZeroBytes(content.Get<BinaryDataBox>().payload);
  }
  if (content.Holds<EmbeddedFileDescriptionBox>()) {
    // We don't (yet) require redaction of the file description.
    return true;
  }
  return false;
}

bool ContainsAllZeroBytes(const jumbf::SuperBox& box) {
  return std::all_of(
      box.contents.begin(), box.contents.end(),
      [](const auto& content) { return ContainsAllZeroBytes(content); });
}

void ValidateRedactionsAllowed(const Claim& claim,
                               ValidationTracker& validation_tracker) {
  // Note that the selfRedacted check is done in ManifestGraph.
  const AssertionTypeMatcher actions_v1_matcher(kActionsAssertionV1Label);
  const AssertionTypeMatcher actions_v2_matcher(kActionsAssertionV2Label);
  for (const auto& redacted_assertion : claim.redacted_assertions()) {
    absl::string_view label = Basename(redacted_assertion);
    if (actions_v1_matcher.Matches(label) ||
        actions_v2_matcher.Matches(label)) {
      validation_tracker.RecordFailure(
          FailureStatusCode::kAssertionActionRedacted,
          {.url = absl::StrCat(kAssertionStoreLabel, kManifestLabelDelimiter,
                               label)});
    }
  }
}

// Returns true if `path` is a child of `parent`.
bool IsChildPath(absl::string_view path, absl::string_view parent) {
  if (!absl::StartsWith(path, parent)) return false;
  if (path.size() <= parent.size()) return false;
  if (path[parent.size()] != '/') return false;
  return path.find('/', parent.size() + 1) == absl::string_view::npos;
}

// Returns true if the validation succeeded.
bool ValidateRedactedAssertion(absl::string_view path,
                               const jumbf::UriResolver& uri_resolver,
                               ValidationTracker& validation_tracker) {
  // https://spec.c2pa.org/specifications/specifications/2.4/specs/C2PA_Specification.html#_claim_signature_hash_validation_method
  // "if the referenced assertion is present and its data consists of anything
  // other than zero or more 0x00 bytes, the claim shall be rejected with a
  // failure code of assertion.notRedacted."

  auto box = uri_resolver.ResolvePath(path);
  if (!box.ok()) {
    return true;
  }
  if (!ContainsAllZeroBytes(**box)) {
    validation_tracker.RecordFailure(FailureStatusCode::kAssertionNotRedacted,
                                     {.url = path});
    return false;
  }
  return true;
}

std::optional<HashedUri> ConvertToHashedUri(
    const InternalOrExternalHashedUri& uri, absl::string_view default_algorithm,
    absl::string_view claim_uri, ValidationTracker& validation_tracker) {
  if (!uri.has_url()) {
    validation_tracker.RecordFailure(
        FailureStatusCode::kHashedUriMissing,
        {.url = claim_uri, .explanation = "Icon URI is missing"});
    return std::nullopt;
  }
  if (!absl::StartsWith(uri.url(), "self#jumbf=")) {
    validation_tracker.RecordFailure(
        FailureStatusCode::kGoogleHashedUriUnsupported,
        {.url = claim_uri,
         .explanation = "Icon URI is pointing to an external resource"});
    return std::nullopt;
  }
  HashedUri hashed_uri;
  hashed_uri.set_url(uri.url());
  hashed_uri.set_hash(uri.hash());
  hashed_uri.set_algorithm(uri.has_algorithm() ? uri.algorithm()
                                               : default_algorithm);
  return hashed_uri;
}

void ValidateAssertion(
    const HashedUri& hashed_uri, absl::string_view manifest_path,
    ManifestType manifest_type,
    const absl::flat_hash_set<std::string>& redacted_assertion_paths,
    const HashedUriValidator& assertion_uri_validator,
    const ReferencesValidator& references_validator,
    absl::string_view assertion_store_path, const Claim& claim,
    const jumbf::UriResolver& uri_resolver,
    const AssertionParser& assertion_parser,
    google::protobuf::RepeatedPtrField<Assertion>* assertions_out,
    absl::flat_hash_set<std::string>& assertion_labels,
    ValidationTracker& validation_tracker,
    AssertionCounter& assertion_counter) {
  auto assertion_path = jumbf::UriResolver::GetAbsolutePathFromUri(
      hashed_uri.url(), manifest_path);
  if (!assertion_path.ok()) {
    validation_tracker.RecordFailure(
        FailureStatusCode::kAssertionMissing,
        {.explanation = "malformed assertion URI"});
    return;
  }
  if (redacted_assertion_paths.contains(*assertion_path)) {
    if (ValidateRedactedAssertion(*assertion_path, uri_resolver,
                                  validation_tracker)) {
      Assertion* redacted_assertion = assertions_out->Add();
      redacted_assertion->set_label(Basename(*assertion_path));
      redacted_assertion->mutable_redacted_by_generator();
    }
    // Don't treat the redacted assertion as undeclared.
    assertion_labels.insert(std::string(Basename(*assertion_path)));
    return;
  }
  if (!assertion_uri_validator
           .Validate(hashed_uri, absl::StrCat("self#jumbf=", *assertion_path),
                     validation_tracker)
           .has_value()) {
    return;  // Failure has been recorded by Validate().
  }
  validation_tracker.RecordSuccess(
      SuccessStatusCode::kAssertionHashedUriMatch,
      {.url = absl::StrCat("self#jumbf=", *assertion_path)});
  if (!absl::StartsWith(*assertion_path, manifest_path)) {
    validation_tracker.RecordFailure(
        FailureStatusCode::kAssertionOutsideManifest,
        {.url = claim.label(),
         .explanation =
             absl::StrCat("Violated claim assertion: ", *assertion_path)});
    return;
  }
  if (!IsChildPath(*assertion_path, assertion_store_path)) {
    validation_tracker.RecordFailure(
        FailureStatusCode::kAssertionMissing,
        {.url = claim.label(),
         .explanation =
             absl::StrCat("Violated claim assertion: ", *assertion_path)});
    return;
  }
  auto assertion_box = uri_resolver.ResolvePath(*assertion_path);
  if (!assertion_box.ok()) {
    // Can't happen -- assertion_uri_validator.Validate would have failed.
    DLOG(FATAL) << "unexpected missing assertion: " << assertion_box.status();
    validation_tracker.RecordFailure(
        FailureStatusCode::kGoogleInternalError,
        {.url = claim.label(), .explanation = "unexpected missing assertion"});
    return;
  }
  ValidateAssertionContents(*assertion_box, manifest_type, assertion_parser,
                            references_validator, assertions_out,
                            validation_tracker, assertion_counter);
  assertion_labels.insert(std::string(Basename(*assertion_path)));
}

void ValidateClaimGeneratorIcon(const Claim& claim,
                                absl::string_view manifest_path,
                                const HashedUriValidator& hashed_uri_validator,
                                ValidationTracker& validation_tracker) {
  if (!claim.claim_generator_info().has_icon()) {
    return;
  }
  std::optional<HashedUri> icon_hashed_uri = ConvertToHashedUri(
      claim.claim_generator_info().icon(), claim.default_algorithm(),
      claim.label(), validation_tracker);
  if (icon_hashed_uri.has_value()) {
    auto icon_path = jumbf::UriResolver::GetAbsolutePathFromUri(
        icon_hashed_uri->url(), manifest_path);
    if (!icon_path.ok()) {
      // The only way this can happen is if the icon URI doesn't start with
      // "self#jumbf=". This would have already been caught by
      // ConvertToHashedUri.
      validation_tracker.RecordFailure(
          FailureStatusCode::kHashedUriMissing,
          {.url = claim.label(), .explanation = "Icon URI is malformed"});
    } else if (hashed_uri_validator
                   .Validate(*icon_hashed_uri, claim.label(),
                             validation_tracker)
                   .has_value()) {
      // No success code for icon URI validation. See
      // https://spec.c2pa.org/specifications/specifications/2.4/specs/C2PA_Specification.html#_validation_of_references
    }
  }
}

void ValidateUndeclaredAssertions(
    absl::string_view assertion_store_path,
    const absl::flat_hash_set<std::string>& assertion_labels,
    const jumbf::UriResolver& uri_resolver,
    ValidationTracker& validation_tracker) {
  auto assertion_store_box = uri_resolver.ResolvePath(assertion_store_path);
  if (!assertion_store_box.ok()) {
    return;
  }
  for (const auto& content : (*assertion_store_box)->contents) {
    if (!content.Holds<SuperBox>()) {
      validation_tracker.RecordFailure(
          FailureStatusCode::kAssertionUndeclared,
          {.explanation =
               "Assertion store contains a box that is not a superbox."});
      continue;
    }
    const SuperBox& assertion_box = content.Get<SuperBox>();
    auto assertion_label = assertion_box.description.label.value_or("");
    if (!assertion_labels.contains(assertion_label)) {
      validation_tracker.RecordFailure(
          FailureStatusCode::kAssertionUndeclared,
          {.url = absl::StrCat(kAssertionStoreLabel, kManifestLabelDelimiter,
                               assertion_label)});
      continue;
    }
  }
}

}  // namespace

void AssertionValidator::ValidateClaimAssertions(
    const jumbf::UriResolver& uri_resolver,
    const absl::flat_hash_set<std::string>& redacted_assertion_paths,
    Manifest& manifest, ValidationTracker& validation_tracker) const {
  std::string manifest_path = absl::StrCat("/c2pa/", manifest.label());
  const Claim& claim = manifest.claim();
  AssertionCounter assertion_counter;
  auto assertion_store_path =
      jumbf::UriResolver::GetAbsolutePath(kAssertionStoreLabel, manifest_path);
  // Validates claim assertion URIs.
  HashedUriValidator assertion_uri_validator(std::string(manifest_path),
                                             uri_resolver);
  assertion_uri_validator.SetErrorCodes(HashedUriValidator::Codes{
      .missing = FailureStatusCode::kAssertionMissing,
      .mismatch = FailureStatusCode::kAssertionHashedUriMismatch});
  assertion_uri_validator.SetDefaultAlgorithm(claim.default_algorithm());
  HashedUriValidator hashed_uri_validator(std::string(manifest_path),
                                          uri_resolver);
  hashed_uri_validator.SetDefaultAlgorithm(claim.default_algorithm());

  ValidateClaimGeneratorIcon(claim, manifest_path, hashed_uri_validator,
                             validation_tracker);

  ManifestType manifest_type = manifest.is_update_manifest()
                                   ? ManifestType::kUpdateManifest
                                   : ManifestType::kStandardManifest;
  ReferencesValidator references_validator(
      &hashed_uri_validator, manifest.label(), &validation_tracker);
  absl::flat_hash_set<std::string> assertion_labels;
  assertion_labels.reserve(claim.created_assertions_size() +
                           claim.gathered_assertions_size());
  for (const auto& assertions :
       {claim.created_assertions(), claim.gathered_assertions()}) {
    for (const HashedUri& hashed_uri : assertions) {
      ValidateAssertion(
          hashed_uri, manifest_path, manifest_type, redacted_assertion_paths,
          assertion_uri_validator, references_validator, assertion_store_path,
          claim, uri_resolver, assertion_parser_, manifest.mutable_assertions(),
          assertion_labels, validation_tracker, assertion_counter);
    }
  }

  // Validate that this claim's redactions are allowed.
  ValidateRedactionsAllowed(claim, validation_tracker);

  switch (manifest_type) {
    case ManifestType::kUpdateManifest:
      assertion_counter.ValidateUpdateManifestCounts(claim.label(),
                                                     validation_tracker);
      break;
    case ManifestType::kStandardManifest:
      assertion_counter.ValidateStandardManifestCounts(claim.label(),
                                                       validation_tracker);
      break;
  }

  assertion_counter.ValidateSoftBinding(claim.label(), validation_tracker);

  // Validates any undeclared assertions.
  ValidateUndeclaredAssertions(assertion_store_path, assertion_labels,
                               uri_resolver, validation_tracker);

  if (!options_.skip_actions_assertion_validation_for_test) {
    ActionsAssertionValidator actions_validator;
    actions_validator.Validate(manifest, validation_tracker);
  }
}

}  // namespace credentio