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

#include <algorithm>
#include <cstdint>
#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "absl/container/flat_hash_map.h"
#include "absl/status/status.h"
#include "absl/status/status_macros.h"
#include "absl/status/statusor.h"
#include "absl/strings/str_format.h"
#include "absl/strings/string_view.h"
#include "bindings/input_hasher.h"
#include "bindings/merkle.h"
#include "cbor/cbor.h"
#include "cbor/parse.h"
#include "constants/labels.h"
#include "constants/status_codes.h"
#include "crypto/hash.h"
#include "formats/bmff/box_header.h"
#include "proto/bmff_based_hash_assertion.cbor.h"
#include "proto/bmff_based_hash_assertion.pb.h"
#include "riegeli/bytes/reader.h"
#include "utils/riegeli.h"
#include "utils/status_tracker.h"

namespace credentio {

namespace {

std::string GetMerkleKey(int64_t unique_id, int64_t local_id) {
  return absl::StrFormat("%d-%d", unique_id, local_id);
}

absl::StatusOr<std::string> ReadPurpose(riegeli::Reader& contents) {
  std::string purpose;
  if (!ReadNullTerminatedString(contents, 20, purpose)) {
    return contents.StatusOrAnnotate(absl::DataLossError("kUnexpectedEof"));
  }
  return purpose;
}

absl::StatusOr<BmffMerkleMap> ReadBmffMerkleMap(riegeli::Reader& contents,
                                                int64_t length) {
  constexpr int64_t kMaxMerkleMapSize = 10 * 1024 * 1024;  // 10 MiB
  if (length < 0 || length > kMaxMerkleMapSize) {
    return absl::InvalidArgumentError(
        absl::StrFormat("invalid length for merkle map: %d", length));
  }
  std::string aux_box_raw;
  if (!contents.Read(length, aux_box_raw)) {
    return absl::InternalError("failed to read auxiliary merkle map");
  }

  BmffMerkleMap aux_box;
  ABSL_ASSIGN_OR_RETURN(auto aux_box_cbor, cbor::Parse(aux_box_raw));
  ABSL_ASSIGN_OR_RETURN(auto aux_box_cbor_map, aux_box_cbor->AsMap());
  ABSL_RETURN_IF_ERROR(cbor::ToProto(aux_box_cbor_map, &aux_box));
  return aux_box;
}

absl::StatusOr<std::string> ComputeLeafHash(const HasherFactory& factory,
                                            riegeli::Reader& contents,
                                            int64_t offset, int64_t length) {
  ABSL_ASSIGN_OR_RETURN(auto hasher, factory.Create());
  ABSL_ASSIGN_OR_RETURN(auto input_hasher,
                        InputHasher::Create(std::move(hasher)));
  ABSL_RETURN_IF_ERROR(input_hasher->Update(contents, offset, length));
  return input_hasher->Digest();
}

absl::StatusOr<std::string> JoinHashes(const HasherFactory& factory,
                                       absl::string_view hash1,
                                       absl::string_view hash2) {
  ABSL_ASSIGN_OR_RETURN(auto hasher, factory.Create());
  hasher->Update(hash1);
  hasher->Update(hash2);
  return hasher->Digest();
}

struct LeafData {
  std::vector<BmffBoxHeader> mdat_atoms;
  absl::flat_hash_map<std::string, std::vector<BmffMerkleMap>> auxiliary_data;
};

absl::StatusOr<LeafData> ExtractLeafData(riegeli::Reader& contents) {
  LeafData result;

  if (!contents.Seek(0) || contents.pos() != 0) {
    return absl::InternalError("failed to seek to start of file");
  }
  auto status = IterateOverBmffBoxes(
      contents,
      [&result,
       &contents](const BmffBoxHeader& header) -> absl::StatusOr<bool> {
        // Non-fragmented assets have 1 merkle tree per `mdat`
        // Fragmented assets could have merkle tree per track
        // https://spec.c2pa.org/specifications/specifications/2.2/specs/C2PA_Specification.html#_general_20
        if (header.type == "mdat") {
          // Non-fragmented assets require auxiliary data after the last mdat.
          // https://spec.c2pa.org/specifications/specifications/2.2/specs/C2PA_Specification.html#_non_fragmented_asset_that_can_be_validated_piecewise
          if (!result.auxiliary_data.empty()) {
            return absl::InvalidArgumentError(
                "encountered auxiliary atom before the first mdat atom");
          }
          result.mdat_atoms.push_back(header);
        }
        if (header.type == "uuid" &&
            header.user_type == credentio::kC2paBmffBoxUuid) {
          // Read next string to determine the purpose of the uuid atom.
          ABSL_ASSIGN_OR_RETURN(auto purpose, ReadPurpose(contents));

          if (purpose == "merkle") {
            uint64_t end_of_box = header.start + header.box_size;
            if (contents.pos() >= end_of_box) {
              return absl::InvalidArgumentError(
                  "box size too small for metadata headers");
            }
            uint64_t remaining_data = end_of_box - contents.pos();
            ABSL_ASSIGN_OR_RETURN(auto aux_box,
                                  ReadBmffMerkleMap(contents, remaining_data));

            result
                .auxiliary_data[GetMerkleKey(aux_box.unique_id(),
                                             aux_box.local_id())]
                .push_back(aux_box);
          }
        }
        return true;
      });
  ABSL_RETURN_IF_ERROR(status);
  return result;
}

}  // namespace

absl::Status MerkleValidator::ValidateMerkleMap(
    const BmffMerkle& merkle, const BmffBoxHeader& mdat_atom,
    std::vector<BmffMerkleMap> auxiliary_merkle_maps,
    absl::string_view fallback_algo, StatusTracker& tracker) const {
  if (merkle.has_init_hash()) {
    tracker.RecordFailure(
        FailureStatusCode::kGoogleInternalError,
        {.url = assertion_uri_,
         .explanation = "fragmented merkle validations are not supported yet"});
    return absl::UnimplementedError(
        "fragmented merkle validations are not supported yet");
  }

  // Derive the full row sizes and number of rows away and validates the counts.
  absl::StatusOr<DerivedTreeData> derived_data = DeriveMerkleTreeData(
      merkle.count(), merkle.hashes_size(), auxiliary_merkle_maps.size());
  if (!derived_data.ok()) {
    tracker.RecordFailure(FailureStatusCode::kAssertionBmffHashMalformed,
                          {.url = assertion_uri_,
                           .explanation = derived_data.status().message()});
    return derived_data.status();
  }

  uint64_t mdat_offset_adjustment = 0;
  for (const auto& exclusion : assertion_.exclusions()) {
    if (exclusion.xpath() == "/mdat" && !exclusion.subsets().empty()) {
      mdat_offset_adjustment = exclusion.subsets(0).offset();
      break;
    }
  }

  uint64_t header_or_adjustment_size =
      std::max<uint64_t>(mdat_atom.header_size, mdat_offset_adjustment);

  if (mdat_atom.box_size < header_or_adjustment_size) {
    tracker.RecordFailure(
        FailureStatusCode::kAssertionBmffHashMalformed,
        {.url = assertion_uri_,
         .explanation = "mdat atom box_size is smaller than header_size or "
                        "exclusion adjustment"});
    return absl::InvalidArgumentError(
        "mdat atom box_size is smaller than header_size or exclusion "
        "adjustment");
  }

  // Calculate and validate the lengths of each leaf using net payload size.
  uint64_t net_mdat_payload_size =
      mdat_atom.box_size - header_or_adjustment_size;
  absl::StatusOr<std::vector<int64_t>> leaf_sizes =
      DeriveMerkleBlockSizes(merkle, net_mdat_payload_size);
  if (!leaf_sizes.ok()) {
    tracker.RecordFailure(
        FailureStatusCode::kAssertionBmffHashMalformed,
        {.url = assertion_uri_, .explanation = leaf_sizes.status().message()});
    return leaf_sizes.status();
  }

  // Based on the above calculations, we ensure the assertion is not malformed,
  // now compute and compare the leaf hashes.
  uint64_t offset = mdat_atom.start + header_or_adjustment_size;
  for (int64_t i = 0; i < merkle.count(); ++i) {
    absl::string_view algo = merkle.has_alg() ? merkle.alg() : fallback_algo;
    absl::StatusOr<std::unique_ptr<HasherFactory>> factory =
        factory_provider_->Create(algo);
    if (!factory.ok()) {
      tracker.RecordFailure(FailureStatusCode::kAssertionBmffHashMalformed,
                            {.url = assertion_uri_,
                             .explanation = absl::StrFormat(
                                 "unsupported hash algorithm: %s", algo)});
      return absl::InvalidArgumentError(
          absl::StrFormat("unsupported hash algorithm: %s", algo));
    }

    absl::StatusOr<std::string> leaf_hash =
        ComputeLeafHash(**factory, contents_, offset, leaf_sizes.value()[i]);
    offset += leaf_sizes.value()[i];
    if (!leaf_hash.ok()) {
      tracker.RecordFailure(
          FailureStatusCode::kAssertionBmffHashMalformed,
          {.url = assertion_uri_, .explanation = leaf_hash.status().message()});
      return leaf_hash.status();
    }

    std::string computed_hash = std::move(leaf_hash.value());

    uint64_t running_row_index = i;
    if (!auxiliary_merkle_maps.empty()) {
      BmffMerkleMap auxiliary = auxiliary_merkle_maps[i];
      int64_t location = auxiliary.location();
      uint64_t lvl = 0;
      int64_t trailing_boundary = (merkle.count() - 1) & ~1LL;
      for (const auto& hash : auxiliary.hashes()) {
        bool sibling_on_left = (running_row_index % 2 == 1) ||
                               (location >= trailing_boundary && lvl >= 1);
        if (sibling_on_left) {
          ABSL_ASSIGN_OR_RETURN(computed_hash,
                                JoinHashes(**factory, hash, computed_hash));
        } else {
          ABSL_ASSIGN_OR_RETURN(computed_hash,
                                JoinHashes(**factory, computed_hash, hash));
        }
        running_row_index >>= 1;
        ++lvl;
      }
    }

    uint64_t hashes_index = i >> derived_data->delta_rows;
    if (merkle.hashes(hashes_index) != computed_hash) {
      tracker.RecordFailure(FailureStatusCode::kAssertionBmffHashMismatch,
                            {.url = assertion_uri_,
                             .explanation = absl::StrFormat(
                                 "merkle map hash mismatch on leaf: %d", i)});
      return absl::InternalError("merkle map hash mismatch");
    }
  }
  return absl::OkStatus();
}

absl::Status MerkleValidator::Validate(StatusTracker& tracker) const {
  absl::StatusOr<LeafData> atoms = ExtractLeafData(contents_);
  if (!atoms.ok()) {
    tracker.RecordFailure(
        FailureStatusCode::kGoogleInternalError,
        {.url = assertion_uri_, .explanation = atoms.status().message()});
    return absl::InternalError("failed to extract leaf data");
  }
  if (atoms->mdat_atoms.size() != assertion_.merkles_size()) {
    // This should only apply to non-fragmented assets.
    tracker.RecordFailure(
        FailureStatusCode::kAssertionBmffHashMalformed,
        {.url = assertion_uri_,
         .explanation =
             "number of mdat atoms does not match the number of merkle maps"});
    return absl::InternalError(
        "number of mdat atoms does not match the number of merkle maps");
  }

  for (int64_t i = 0; i < atoms->mdat_atoms.size(); ++i) {
    BmffMerkle merkle = assertion_.merkles(i);
    const auto& aux_maps = atoms->auxiliary_data[GetMerkleKey(
        merkle.unique_id(), merkle.local_id())];
    ABSL_RETURN_IF_ERROR(ValidateMerkleMap(
        merkle, atoms->mdat_atoms[i], aux_maps, assertion_.alg(), tracker));
  }
  return absl::OkStatus();
}

}  // namespace credentio