// © 2024 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html

// Fuzzer for ICU bidi.

#include <cstring>

#include "fuzzer_utils.h"

#include "unicode/ubidi.h"

#define MAXLEN 200

static void testGetVisualRun(UBiDi *bidi) {
  UErrorCode status = U_ZERO_ERROR;
  ubidi_getDirection(bidi);
  ubidi_getParaLevel(bidi);
  ubidi_getReorderingMode(bidi);
  ubidi_getReorderingOptions(bidi);
  int32_t runCount = ubidi_countRuns(bidi, &status);
  if (U_FAILURE(status)) {
    return;
  }
  for (int32_t runIndex = 0; runIndex < runCount; runIndex++) {
    int32_t start, len;
    ubidi_getVisualRun(bidi, runIndex, &start, &len);
  }
}


static void testVisual(UBiDi *bidi) {
  UErrorCode status = U_ZERO_ERROR;
  int32_t visualToLogical[MAXLEN];
  int32_t logicalToVisual[MAXLEN];
  int32_t logicalLimit = ubidi_getProcessedLength(bidi);
  int32_t visualLimit = ubidi_getResultLength(bidi);
  if (visualLimit > MAXLEN) {
    return;
  }
  ubidi_getVisualMap(bidi, visualToLogical, &status);
  ubidi_getLogicalMap(bidi, logicalToVisual, &status);
  if (U_FAILURE(status)) {
    return;
  }

  bool mapIsIncorrect = false;
  for (int32_t logicalIndex = 0; logicalIndex < logicalLimit; logicalIndex++) {
    int32_t visualIndex = ubidi_getVisualIndex(bidi, logicalIndex, &status);
    if (visualIndex != logicalToVisual[logicalIndex]) {
      mapIsIncorrect = true;
    }
    if (visualIndex != UBIDI_MAP_NOWHERE && visualIndex < visualLimit) {
        UBiDiLevel level;
        ubidi_getLogicalRun(bidi, logicalIndex, nullptr, &level);
    }
  }

  if (U_FAILURE(status)) {
    return;
  }
  bool checkGetVisualRun = true;
  if (mapIsIncorrect) {
    testGetVisualRun(bidi);
    checkGetVisualRun = false;
    for (int32_t logicalIndex = 0; logicalIndex < logicalLimit; logicalIndex++) {
      ubidi_getVisualIndex(bidi, logicalIndex, &status);
    }
  }

  mapIsIncorrect = false;
  for (int32_t visualIndex = 0; visualIndex < visualLimit; visualIndex++) {
    int32_t logicalIndex = ubidi_getLogicalIndex(bidi, visualIndex, &status);
    if (logicalIndex != visualToLogical[visualIndex]) {
      mapIsIncorrect = true;
    }
    if (logicalIndex != UBIDI_MAP_NOWHERE && logicalIndex < logicalLimit) {
      UBiDiLevel level;
      ubidi_getLogicalRun(bidi, logicalIndex, nullptr, &level);
    }
  }
  if (U_FAILURE(status)) {
    return;
  }
  if (mapIsIncorrect && checkGetVisualRun) {
    testGetVisualRun(bidi);
  }
}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
  icu::StringPiece fuzzData(reinterpret_cast<const char *>(data), size);

  UErrorCode status = U_ZERO_ERROR;
  UChar inputText[MAXLEN];
  UChar reorderedText[MAXLEN];

  unsigned char inputTextLength;
  UBiDiLevel paraLevel;
  int16_t options, options2;
  unsigned char reorderedTextSize;
  bool checkSetInverse, checkVisual;
  bool isInverse;

  if (static_cast<size_t>(fuzzData.length()) <
      sizeof(inputTextLength) + sizeof(paraLevel) + sizeof(options) +
      sizeof(reorderedTextSize) + sizeof(checkSetInverse) + sizeof(checkVisual) +
      sizeof(isInverse) + sizeof(options2) + sizeof(UChar)) {
    return 0;
  }
  std::memcpy(&inputTextLength, fuzzData.data(), sizeof(inputTextLength));
  fuzzData.remove_prefix(sizeof(inputTextLength));

  std::memcpy(&paraLevel, fuzzData.data(), sizeof(paraLevel));
  fuzzData.remove_prefix(sizeof(paraLevel));

  std::memcpy(&options, fuzzData.data(), sizeof(options));
  fuzzData.remove_prefix(sizeof(options));

  std::memcpy(&reorderedTextSize, fuzzData.data(), sizeof(reorderedTextSize));
  fuzzData.remove_prefix(sizeof(reorderedTextSize));
  if (reorderedTextSize > MAXLEN) reorderedTextSize = MAXLEN;

  checkSetInverse = (*(fuzzData.data()) & 0x01) == 0;
  fuzzData.remove_prefix(sizeof(checkSetInverse));

  checkVisual = (*(fuzzData.data()) & 0x01) == 0;
  fuzzData.remove_prefix(sizeof(checkVisual));

  isInverse = (*(fuzzData.data()) & 0x01) != 0;
  fuzzData.remove_prefix(sizeof(isInverse));

  std::memcpy(&options2, fuzzData.data(), sizeof(options2));
  fuzzData.remove_prefix(sizeof(options2));

  if (inputTextLength > MAXLEN) inputTextLength = MAXLEN;
  if (inputTextLength > fuzzData.length() / sizeof(UChar)) {
      inputTextLength = fuzzData.length() / sizeof(UChar);
  }
  std::memcpy(&inputText, fuzzData.data(), sizeof(UChar)*inputTextLength);
  fuzzData.remove_prefix(sizeof(UChar)*inputTextLength);

  UBiDi* bidi = ubidi_open();
  if (checkSetInverse) {
    ubidi_setInverse(bidi, isInverse);
  }
  ubidi_setPara(bidi, inputText, inputTextLength, paraLevel, nullptr, &status);
  if (U_SUCCESS(status)) {
    int32_t reorderedTextLength = ubidi_writeReordered(bidi, reorderedText, reorderedTextSize, options, &status);
    if (U_SUCCESS(status)) {
      if (checkVisual) {
        testVisual(bidi);
      } else {
        ubidi_writeReordered(bidi, reorderedText, reorderedTextLength+1, options2, &status);
      }
    }
  }
  ubidi_close(bidi);

  return EXIT_SUCCESS;
}