// © 2016 and later: Unicode, Inc. and others.

// License & terms of use: http://www.unicode.org/copyright.html

/*

*******************************************************************************

*

*   Copyright (C) 1999-2014, International Business Machines

*   Corporation and others.  All Rights Reserved.

*

*******************************************************************************

*   file name:  unistr_case.cpp

*   encoding:   UTF-8

*   tab size:   8 (not used)

*   indentation:2

*

*   created on: 2004aug19

*   created by: Markus W. Scherer

*

*   Case-mapping functions moved here from unistr.cpp

*/

#include "unicode/utypes.h"

#include "unicode/brkiter.h"

#include "unicode/casemap.h"

#include "unicode/edits.h"

#include "unicode/putil.h"

#include "cstring.h"

#include "cmemory.h"

#include "unicode/ustring.h"

#include "unicode/unistr.h"

#include "unicode/uchar.h"

#include "uassert.h"

#include "ucasemap_imp.h"

#include "uelement.h"

U_NAMESPACE_BEGIN

//========================================

// Read-only implementation

//========================================

int8_t

UnicodeString::doCaseCompare(int32_t start,

                             int32_t length,

                             const UChar *srcChars,

                             int32_t srcStart,

                             int32_t srcLength,

                             uint32_t options) const

{

  // compare illegal string values

  // treat const UChar *srcChars==NULL as an empty string

  if(isBogus()) {

    return -1;

  }

  // pin indices to legal values

  pinIndices(start, length);

  if(srcChars == NULL) {

    srcStart = srcLength = 0;

  }

  // get the correct pointer

  const UChar *chars = getArrayStart();

  chars += start;

  if(srcStart!=0) {

    srcChars += srcStart;

  }

  if(chars != srcChars) {

    UErrorCode errorCode=U_ZERO_ERROR;

    int32_t result=u_strcmpFold(chars, length, srcChars, srcLength,

                                options|U_COMPARE_IGNORE_CASE, &errorCode);

    if(result!=0) {

      return (int8_t)(result >> 24 | 1);

    }

  } else {

    // get the srcLength if necessary

    if(srcLength < 0) {

      srcLength = u_strlen(srcChars + srcStart);

    }

    if(length != srcLength) {

      return (int8_t)((length - srcLength) >> 24 | 1);

    }

  }

  return 0;

}

//========================================

// Write implementation

//========================================

UnicodeString &

UnicodeString::caseMap(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_PARAM

                       UStringCaseMapper *stringCaseMapper) {

  if(isEmpty() || !isWritable()) {

    // nothing to do

    return *this;

  }

  UChar oldBuffer[2 * US_STACKBUF_SIZE];

  UChar *oldArray;

  int32_t oldLength = length();

  int32_t newLength;

  UBool writable = isBufferWritable();

  UErrorCode errorCode = U_ZERO_ERROR;

#if !UCONFIG_NO_BREAK_ITERATION

  // Read-only alias to the original string contents for the titlecasing BreakIterator.

  // We cannot set the iterator simply to *this because *this is being modified.

  UnicodeString oldString;

#endif

  // Try to avoid heap-allocating a new character array for this string.

  if (writable ? oldLength <= UPRV_LENGTHOF(oldBuffer) : oldLength < US_STACKBUF_SIZE) {

    // Short string: Copy the contents into a temporary buffer and

    // case-map back into the current array, or into the stack buffer.

    UChar *buffer = getArrayStart();

    int32_t capacity;

    oldArray = oldBuffer;

    u_memcpy(oldBuffer, buffer, oldLength);

    if (writable) {

      capacity = getCapacity();

    } else {

      // Switch from the read-only alias or shared heap buffer to the stack buffer.

      if (!cloneArrayIfNeeded(US_STACKBUF_SIZE, US_STACKBUF_SIZE, /* doCopyArray= */ FALSE)) {

        return *this;

      }

      U_ASSERT(fUnion.fFields.fLengthAndFlags & kUsingStackBuffer);

      buffer = fUnion.fStackFields.fBuffer;

      capacity = US_STACKBUF_SIZE;

    }

#if !UCONFIG_NO_BREAK_ITERATION

    if (iter != nullptr) {

      oldString.setTo(FALSE, oldArray, oldLength);

      iter->setText(oldString);

    }

#endif

    newLength = stringCaseMapper(caseLocale, options, UCASEMAP_BREAK_ITERATOR

                                 buffer, capacity,

                                 oldArray, oldLength, NULL, errorCode);

    if (U_SUCCESS(errorCode)) {

      setLength(newLength);

      return *this;

    } else if (errorCode == U_BUFFER_OVERFLOW_ERROR) {

      // common overflow handling below

    } else {

      setToBogus();

      return *this;

    }

  } else {

    // Longer string or read-only buffer:

    // Collect only changes and then apply them to this string.

    // Case mapping often changes only small parts of a string,

    // and often does not change its length.

    oldArray = getArrayStart();

    Edits edits;

    UChar replacementChars[200];

#if !UCONFIG_NO_BREAK_ITERATION

    if (iter != nullptr) {

      oldString.setTo(FALSE, oldArray, oldLength);

      iter->setText(oldString);

    }

#endif

    stringCaseMapper(caseLocale, options | U_OMIT_UNCHANGED_TEXT, UCASEMAP_BREAK_ITERATOR

                     replacementChars, UPRV_LENGTHOF(replacementChars),

                     oldArray, oldLength, &edits, errorCode);

    if (U_SUCCESS(errorCode)) {

      // Grow the buffer at most once, not for multiple doReplace() calls.

      newLength = oldLength + edits.lengthDelta();

      if (newLength > oldLength && !cloneArrayIfNeeded(newLength, newLength)) {

        return *this;

      }

      for (Edits::Iterator ei = edits.getCoarseChangesIterator(); ei.next(errorCode);) {

        doReplace(ei.destinationIndex(), ei.oldLength(),

                  replacementChars, ei.replacementIndex(), ei.newLength());

      }

      if (U_FAILURE(errorCode)) {

        setToBogus();

      }

      return *this;

    } else if (errorCode == U_BUFFER_OVERFLOW_ERROR) {

      // common overflow handling below

      newLength = oldLength + edits.lengthDelta();

    } else {

      setToBogus();

      return *this;

    }

  }

  // Handle buffer overflow, newLength is known.

  // We need to allocate a new buffer for the internal string case mapping function.

  // This is very similar to how doReplace() keeps the old array pointer

  // and deletes the old array itself after it is done.

  // In addition, we are forcing cloneArrayIfNeeded() to always allocate a new array.

  int32_t *bufferToDelete = 0;

  if (!cloneArrayIfNeeded(newLength, newLength, FALSE, &bufferToDelete, TRUE)) {

    return *this;

  }

  errorCode = U_ZERO_ERROR;

  // No need to iter->setText() again: The case mapper restarts via iter->first().

  newLength = stringCaseMapper(caseLocale, options, UCASEMAP_BREAK_ITERATOR

                               getArrayStart(), getCapacity(),

                               oldArray, oldLength, NULL, errorCode);

  if (bufferToDelete) {

    uprv_free(bufferToDelete);

  }

  if (U_SUCCESS(errorCode)) {

    setLength(newLength);

  } else {

    setToBogus();

  }

  return *this;

}

UnicodeString &

UnicodeString::foldCase(uint32_t options) {

  return caseMap(UCASE_LOC_ROOT, options, UCASEMAP_BREAK_ITERATOR_NULL ustrcase_internalFold);

}

U_NAMESPACE_END

// Defined here to reduce dependencies on break iterator

U_CAPI int32_t U_EXPORT2

uhash_hashCaselessUnicodeString(const UElement key) {

    U_NAMESPACE_USE

    const UnicodeString *str = (const UnicodeString*) key.pointer;

    if (str == NULL) {

        return 0;

    }

    // Inefficient; a better way would be to have a hash function in

    // UnicodeString that does case folding on the fly.

    UnicodeString copy(*str);

    return copy.foldCase().hashCode();

}

// Defined here to reduce dependencies on break iterator

U_CAPI UBool U_EXPORT2

uhash_compareCaselessUnicodeString(const UElement key1, const UElement key2) {

    U_NAMESPACE_USE

    const UnicodeString *str1 = (const UnicodeString*) key1.pointer;

    const UnicodeString *str2 = (const UnicodeString*) key2.pointer;

    if (str1 == str2) {

        return TRUE;

    }

    if (str1 == NULL || str2 == NULL) {

        return FALSE;

    }

    return str1->caseCompare(*str2, U_FOLD_CASE_DEFAULT) == 0;

}