// Copyright 2024 Google LLC
// SPDX-License-Identifier: BSD-2-Clause

#include <array>
#include <cstdint>
#include <cstring>
#include <memory>
#include <vector>

#include "avif/avif.h"
#include "avif/internal.h"
#include "avif_fuzztest_helpers.h"
#include "aviftest_helpers.h"
#include "fuzztest/fuzztest.h"
#include "gtest/gtest.h"

namespace avif {
namespace testutil {
namespace {

struct TestProp {
  std::array<uint8_t, 4> fourcc;
  std::array<uint8_t, 16> uuid;
  std::vector<uint8_t> body;
};

void EncodeDecode(ImagePtr image, EncoderPtr encoder, DecoderPtr decoder,
                  const std::vector<TestProp>& test_props) {
  ImagePtr decoded_image(avifImageCreateEmpty());
  ASSERT_NE(image.get(), nullptr);
  ASSERT_NE(encoder.get(), nullptr);
  ASSERT_NE(decoder.get(), nullptr);
  ASSERT_NE(decoded_image.get(), nullptr);

  std::vector<TestProp> valid_test_properties;
  for (const TestProp& testProp : test_props) {
    if (testProp.fourcc == std::array<uint8_t, 4>{'u', 'u', 'i', 'd'}) {
      const avifResult result =
          avifImageAddUUIDProperty(image.get(), testProp.uuid.data(),
                                   testProp.body.data(), testProp.body.size());
      if (avifIsValidUUID(testProp.uuid.data())) {
        valid_test_properties.push_back(testProp);
        ASSERT_EQ(result, AVIF_RESULT_OK);
      } else {
        ASSERT_EQ(result, AVIF_RESULT_INVALID_ARGUMENT);
      }
    } else {
      const avifResult result = avifImageAddOpaqueProperty(
          image.get(), testProp.fourcc.data(), testProp.body.data(),
          testProp.body.size());
      if (avifIsKnownPropertyType(testProp.fourcc.data())) {
        ASSERT_EQ(result, AVIF_RESULT_INVALID_ARGUMENT);
      } else {
        valid_test_properties.push_back(testProp);
        ASSERT_EQ(result, AVIF_RESULT_OK);
      }
    }
  }

  AvifRwData encoded_data;
  const avifResult encoder_result =
      avifEncoderWrite(encoder.get(), image.get(), &encoded_data);
  ASSERT_EQ(encoder_result, AVIF_RESULT_OK)
      << avifResultToString(encoder_result);

  const avifResult decoder_result = avifDecoderReadMemory(
      decoder.get(), decoded_image.get(), encoded_data.data, encoded_data.size);
  ASSERT_EQ(decoder_result, AVIF_RESULT_OK)
      << avifResultToString(decoder_result);

  ASSERT_EQ(decoder->image->numProperties, valid_test_properties.size());
  for (size_t i = 0; i < valid_test_properties.size(); i++) {
    const TestProp& testProp = valid_test_properties[i];
    const avifImageItemProperty& decodeProp = decoder->image->properties[i];
    EXPECT_EQ(std::string(decodeProp.boxtype, decodeProp.boxtype + 4),
              std::string(testProp.fourcc.data(), testProp.fourcc.data() + 4));
    EXPECT_EQ(std::vector<uint8_t>(
                  decodeProp.boxPayload.data,
                  decodeProp.boxPayload.data + decodeProp.boxPayload.size),
              testProp.body);
  }
}

inline auto ArbitraryProp() {
  auto fourcc = fuzztest::Arbitrary<std::array<uint8_t, 4>>();
  auto uuid = fuzztest::Arbitrary<std::array<uint8_t, 16>>();  // ignored
  auto body = fuzztest::Arbitrary<std::vector<uint8_t>>();
  return fuzztest::StructOf<TestProp>(fourcc, uuid, body);
}

inline auto ArbitraryUUIDProp() {
  auto fourcc = fuzztest::Just(std::array<uint8_t, 4>{'u', 'u', 'i', 'd'});
  auto uuid = fuzztest::Arbitrary<std::array<uint8_t, 16>>();
  auto body = fuzztest::Arbitrary<std::vector<uint8_t>>();
  return fuzztest::StructOf<TestProp>(fourcc, uuid, body);
}

inline auto ArbitraryProps() {
  return fuzztest::VectorOf(
             fuzztest::OneOf(ArbitraryProp(), ArbitraryUUIDProp()))
      .WithMaxSize(
          /*maximum unique property count for an avifEncoder instance*/ 127 -
          /*maximum unique property count used by libavif*/ 16);
}

FUZZ_TEST(PropertiesAvifFuzzTest, EncodeDecode)
    .WithDomains(ArbitraryAvifImage(), ArbitraryAvifEncoder(),
                 ArbitraryAvifDecoder(), ArbitraryProps());

}  // namespace
}  // namespace testutil
}  // namespace avif