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

#include <string>

#include "absl/container/flat_hash_map.h"
#include "absl/container/flat_hash_set.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "absl/strings/string_view.h"
#include "constants/ingredient_relationships.h"
#include "constants/labels.h"
#include "constants/status_codes.h"
#include "proto/actions_assertion.pb.h"
#include "proto/assertion.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 {

absl::string_view Basename(absl::string_view path) {
  return path.substr(path.find_last_of('/') + 1);
}

bool RequiresParentOfRelationship(absl::string_view action) {
  return action == "c2pa.opened" || action == "c2pa.repackaged" ||
         action == "c2pa.transcoded";
}

bool RequiresComponentOfRelationship(absl::string_view action) {
  return action == "c2pa.placed" || action == "c2pa.removed";
}

bool RequiresIngredientValidation(absl::string_view action) {
  return RequiresParentOfRelationship(action) ||
         RequiresComponentOfRelationship(action);
}

template <class IngredientAssertionType>
bool ValidateIngredientRelationship(absl::string_view action,
                                    const IngredientAssertionType& ingredient,
                                    absl::string_view assertion_url,
                                    ValidationTracker& validation_tracker) {
  // 3.c.ii.A. Check that the ingredient relationship is parentOf.
  if (RequiresParentOfRelationship(action)) {
    if (ingredient.relationship() != kIngredientRelationshipParentOf) {
      validation_tracker.RecordFailure(
          FailureStatusCode::kAssertionActionIngredientMismatch,
          {.url = assertion_url,
           .explanation = absl::StrFormat(
               "action %s has wrong ingredient relationship: %s; want %s",
               action, ingredient.relationship(),
               kIngredientRelationshipParentOf)});
      return false;
    }
  }
  // 3.c.ii.B. Check that the ingredient relationship is componentOf.
  if (RequiresComponentOfRelationship(action)) {
    if (ingredient.relationship() != kIngredientRelationshipComponentOf) {
      validation_tracker.RecordFailure(
          FailureStatusCode::kAssertionActionIngredientMismatch,
          {.url = assertion_url,
           .explanation = absl::StrFormat(
               "action %s has wrong ingredient relationship: %s; "
               "want %s",
               action, ingredient.relationship(),
               kIngredientRelationshipComponentOf)});
      return false;
    }
  }
  return true;
}

// See
// https://spec.c2pa.org/specifications/specifications/2.4/specs/C2PA_Specification.html#_c2pa_actions_validation.
template <class ActionsAssertionType>
bool ValidateActions(
    const ActionsAssertionType& assertion,
    absl::flat_hash_map<std::string, const Assertion*> assertion_store,
    ValidationTracker& validation_tracker) {
  // 1. Ensure that it has an actions field.
  if (assertion.actions().empty()) {
    validation_tracker.RecordFailure(
        FailureStatusCode::kAssertionActionMalformed, {});
    return false;
  }
  for (auto i = 0; i < assertion.actions().size(); ++i) {
    const auto& action = assertion.actions(i);
    // 3.a. Ensure that it has an action field.
    if (action.action().empty()) {
      validation_tracker.RecordFailure(
          FailureStatusCode::kAssertionActionMalformed,
          {.explanation = "empty action"});
      return false;
    }
    // 3.b. If the action field is c2pa.created or c2pa.opened, it must be the
    // first action.
    if (action.action() == "c2pa.created" || action.action() == "c2pa.opened") {
      if (i != 0) {
        validation_tracker.RecordFailure(
            FailureStatusCode::kAssertionActionMalformed,
            {.explanation = "created/opened not first action"});
        return false;
      }
    }
    // 3.c. Check ingredient for certain actions.
    if (RequiresIngredientValidation(action.action())) {
      // 3.c.i. Check ingredients are present.
      if (!action.has_parameters()) {
        validation_tracker.RecordFailure(
            FailureStatusCode::kAssertionActionIngredientMismatch,
            {.explanation = absl::StrFormat("action %s missing parameters",
                                            action.action())});
        return false;
      }
      if (action.parameters().ingredients().size() == 0) {
        validation_tracker.RecordFailure(
            FailureStatusCode::kAssertionActionIngredientMismatch,
            {.explanation = absl::StrFormat("action %s missing ingredients",
                                            action.action())});
        return false;
      }
      // 3.c.ii. For each ingredient, check that it has a url and it is valid.
      for (const auto& ingredient : action.parameters().ingredients()) {
        if (!ingredient.has_url() || ingredient.url().empty()) {
          validation_tracker.RecordFailure(
              FailureStatusCode::kAssertionActionIngredientMismatch,
              {.explanation = absl::StrFormat(
                   "action %s missing ingredient url", action.action())});
          return false;
        }
        auto label = Basename(ingredient.url());
        if (!assertion_store.contains(label)) {
          validation_tracker.RecordFailure(
              FailureStatusCode::kAssertionActionIngredientMismatch,
              {.explanation = absl::StrFormat(
                   "action %s missing ingredient assertion", action.action())});
          return false;
        }
        auto* assertion = assertion_store[label];
        std::string assertion_url = absl::StrCat(
            kAssertionStoreLabel, kManifestLabelDelimiter, assertion->label());
        if (assertion->has_ingredient_v3()) {
          if (!ValidateIngredientRelationship(
                  action.action(), assertion->ingredient_v3(), assertion_url,
                  validation_tracker)) {
            return false;
          }
        } else {
          validation_tracker.RecordFailure(
              FailureStatusCode::kAssertionActionIngredientMismatch,
              {.url = assertion_url,
               .explanation = absl::StrFormat(
                   "action %s missing ingredient assertion", action.action())});
          return false;
        }
      }
    }
    // 3.d. If the action is c2pa.redacted, check that the redacted field that
    // is a member of the parameters object for the presence of a JUMBF URI and
    // that the URI resolves to an assertion.
    if (action.action() == "c2pa.redacted") {
      if (action.parameters().redacted_uri().empty()) {
        validation_tracker.RecordFailure(
            FailureStatusCode::kAssertionActionRedactionMismatch,
            {.explanation = absl::StrFormat(
                 "action %s missing redacted in parameters", action.action())});
        return false;
      }
      auto redacted_label = Basename(action.parameters().redacted_uri());
      if (!assertion_store.contains(redacted_label)) {
        validation_tracker.RecordFailure(
            FailureStatusCode::kAssertionActionRedactionMismatch,
            {.explanation = absl::StrFormat(
                 "action %s missing redacted assertion", action.action())});
        return false;
      }
    }
  }
  return true;
}

// 2. Check the first action in each actions assertion.
template <class ActionsAssertionType>
bool ValidateFirstAction(absl::string_view label,
                         const ActionsAssertionType& assertion,
                         bool is_first_action_assertion,
                         ValidationTracker& validation_tracker) {
  bool is_created_or_opened =
      assertion.actions_size() > 0 &&
      (assertion.actions(0).action() == "c2pa.created" ||
       assertion.actions(0).action() == "c2pa.opened");
  if (is_first_action_assertion && !is_created_or_opened) {
    validation_tracker.RecordFailure(
        FailureStatusCode::kAssertionActionMalformed,
        {.explanation = "the first action is not c2pa.created or c2pa.opened"});
    return false;
  }
  if (is_created_or_opened && !is_first_action_assertion) {
    validation_tracker.RecordFailure(
        FailureStatusCode::kAssertionActionMalformed,
        {.explanation = "c2pa.created or c2pa.opened is not the first action"});
    return false;
  }
  return true;
}

}  // namespace

bool ActionsAssertionValidator::Validate(
    const Manifest& manifest, ValidationTracker& validation_tracker) const {
  absl::flat_hash_map<std::string, const Assertion*> assertion_store;
  for (const auto& assertion : manifest.assertions()) {
    assertion_store[assertion.label()] = &assertion;
  }
  absl::flat_hash_set<std::string> created_assertions;
  created_assertions.reserve(manifest.claim().created_assertions_size());
  for (const auto& assertion : manifest.claim().created_assertions()) {
    created_assertions.insert(std::string(Basename(assertion.url())));
  }
  bool is_first_action_assertion = true;
  auto validate_actions_assertion = [&](absl::string_view label,
                                        const auto& actions_assertion) -> bool {
    if (!ValidateActions(actions_assertion, assertion_store,
                         validation_tracker)) {
      return false;
    }
    if (created_assertions.contains(label) &&
        !ValidateFirstAction(label, actions_assertion,
                             is_first_action_assertion, validation_tracker)) {
      return false;
    }
    is_first_action_assertion = false;
    return true;
  };

  for (const auto& assertion : manifest.assertions()) {
    if (assertion.has_actions_v1() &&
        !validate_actions_assertion(assertion.label(),
                                    assertion.actions_v1())) {
      return false;
    }
    if (assertion.has_actions() &&
        !validate_actions_assertion(assertion.label(), assertion.actions())) {
      return false;
    }
  }
  return true;
}

}  // namespace credentio