// SPDX-License-Identifier: Apache-2.0

// ----------------------------------------------------------------------------

// Copyright 2026 Arm Limited

//

// 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:

//

//     http://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 "astcenc.h"

#include <fuzzer/FuzzedDataProvider.h>

#include <vector>

#include <iostream>

extern "C" int LLVMFuzzerTestOneInput(

  const uint8_t *data,

  size_t size

) {

  FuzzedDataProvider fdp(data, size);

  // Randomize block size

  // Legal 2D block sizes: 4x4, 5x4, 5x5, 6x5, 6x6, 8x5, 8x6, 8x8, 10x5, 10x6, 10x8, 10x10, 12x10, 12x12

  static const struct { uint8_t x, y; } block_sizes[] = {

    {4, 4}, {5, 4}, {5, 5}, {6, 5}, {6, 6}, {8, 5}, {8, 6}, {8, 8},

    {10, 5}, {10, 6}, {10, 8}, {10, 10}, {12, 10}, {12, 12}

  };

  int bs_idx = fdp.ConsumeIntegralInRange<int>(0, (sizeof(block_sizes) / sizeof(block_sizes[0])) - 1);

  uint32_t block_x = block_sizes[bs_idx].x;

  uint32_t block_y = block_sizes[bs_idx].y;

  uint32_t block_z = 1;

  // Randomize profile

  astcenc_profile profile = (astcenc_profile)fdp.ConsumeIntegralInRange<int>(0, 3);

  // Randomize quality

  float quality = fdp.ConsumeFloatingPointInRange<float>(ASTCENC_PRE_FASTEST, ASTCENC_PRE_EXHAUSTIVE);

  // Randomize flags, but constrain to be safe with arbitrary input data

  unsigned int flags = fdp.ConsumeIntegralInRange<unsigned int>(0, ASTCENC_ALL_FLAGS);

  flags &= ~ASTCENC_FLG_SELF_DECOMPRESS_ONLY;

  astcenc_config config;

  astcenc_error status = astcenc_config_init(profile, block_x, block_y, block_z, quality, flags, &config);

  if (status != ASTCENC_SUCCESS)

  {

    return 0;

  }

  astcenc_context* context = nullptr;

  status = astcenc_context_alloc(&config, 1, &context, nullptr);

  if (status != ASTCENC_SUCCESS)

  {

    return 0;

  }

  // Prepare for decompression

  // We need some "compressed" data. ASTC blocks are 16 bytes.

  // Let's decide how many blocks to decompress.

  size_t num_blocks_x = fdp.ConsumeIntegralInRange<size_t>(1, 4);

  size_t num_blocks_y = fdp.ConsumeIntegralInRange<size_t>(1, 4);

  size_t compressed_data_len = num_blocks_x * num_blocks_y * 16;

  if (fdp.remaining_bytes() < compressed_data_len)

  {

    astcenc_context_free(context);

    return 0;

  }

  std::vector<uint8_t> compressed_data = fdp.ConsumeBytes<uint8_t>(compressed_data_len);

  // Image dimensions

  uint32_t dim_x = num_blocks_x * block_x;

  uint32_t dim_y = num_blocks_y * block_y;

  uint32_t dim_z = 1;

  // Allocate output image

  astcenc_image image_out;

  image_out.dim_x = dim_x;

  image_out.dim_y = dim_y;

  image_out.dim_z = dim_z;

  image_out.data_type = ASTCENC_TYPE_U8;

  uint8_t* slice_data = new uint8_t[dim_x * dim_y * 4];

  void* slices[] = { slice_data };

  image_out.data = slices;

  astcenc_swizzle swizzle = {

    ASTCENC_SWZ_R, ASTCENC_SWZ_G, ASTCENC_SWZ_B, ASTCENC_SWZ_A

  };

  status = astcenc_decompress_image(context, compressed_data.data(), compressed_data.size(), &image_out, &swizzle, 0);

  delete[] slice_data;

  astcenc_context_free(context);

  return 0;

}