#include <algorithm>
#include <cassert>
#include <cstdlib>
#include <type_traits>
#include <vector>

#include "simdutf.h"

void test_latin1_to_utf8(std::span<const uint8_t> input_bytes,
                         std::size_t output_size) {
  std::vector<char> output(output_size);
  const auto written_bytes_safe =
      simdutf::convert_latin1_to_utf8_safe(input_bytes, output);
  if (written_bytes_safe > output_size) {
    std::abort();
  }
  const auto needed_size = simdutf::utf8_length_from_latin1(input_bytes);
  std::vector<char> reference(needed_size);
  const auto written_bytes_unsafe =
      simdutf::convert_latin1_to_utf8(input_bytes, reference);
  if (written_bytes_unsafe != needed_size) {
    std::abort();
  }
  if (written_bytes_safe > needed_size) {
    // convert_latin1_to_utf8_safe wrote more output buffer than the unsafe
    // version needed!
    std::abort();
  }
  // ensure output is equal to the beginning of reference
  if (!std::ranges::equal(
          std::span(output).subspan(0, written_bytes_safe),
          std::span(reference).subspan(0, written_bytes_safe))) {
    std::abort();
  }
}

void test_utf16_to_utf8(std::span<const char16_t> input,
                        std::size_t output_size) {
  std::vector<char> output(output_size);
  const auto written_bytes_safe =
      simdutf::convert_utf16_to_utf8_safe(input, output);
  if (written_bytes_safe > output_size) {
    std::abort();
  }
  // result is implementation defined in case of garbage input
  const auto unreliable_needed_size = simdutf::utf8_length_from_utf16(input);
  std::vector<char> reference(unreliable_needed_size);
  const auto written_bytes_unsafe =
      simdutf::convert_utf16_to_utf8(input, reference);

  // ensure output is equal to the beginning of reference
  const auto Ncompare =
      simdutf::detail::min(written_bytes_safe, written_bytes_unsafe);
  const auto matches =
      std::ranges::equal(std::span(output).subspan(0, Ncompare),
                         std::span(reference).subspan(0, Ncompare));
  assert(matches);
  if (!matches) {
    std::abort();
  }
}

void select_implementation(auto index) {
  static const auto implementations = []() {
    const auto list = simdutf::get_available_implementations();
    using Impl = std::decay_t<decltype(*list.begin())>;
    std::vector<Impl> ret;
    for (auto& e : list) {
      if (e->supported_by_runtime_system()) {
        ret.push_back(e);
      }
    }
    return ret;
  }();
  assert(!implementations.empty());
  simdutf::get_active_implementation() =
      implementations.at(index % implementations.size());
}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {

  if (size < 4) {
    return 0;
  }

  const auto action = data[0] & 0x1;
  const auto output_size = (data[1] << 8 | data[2]);
  const auto implementation_index = data[3] & 0b0111;
  data += 4;
  size -= 4;

  const std::span<const uint8_t> input_bytes{data, data + size};

  select_implementation(implementation_index);

  switch (action) {
  case 0:
    test_latin1_to_utf8(input_bytes, output_size);
    break;
  case 1: {
    const auto* ptr = reinterpret_cast<const char16_t*>(input_bytes.data());
    test_utf16_to_utf8(std::span(ptr, ptr + input_bytes.size() / 2),
                       output_size);
  } break;
  }

  return 0;
}
