/*-------------------------------------------------------------------------
 * unicode_case.c
 *  Unicode case mapping and case conversion.
 *
 * Portions Copyright (c) 2017-2025, PostgreSQL Global Development Group
 *
 * IDENTIFICATION
 *   src/common/unicode_case.c
 *
 *-------------------------------------------------------------------------
 */
#ifndef FRONTEND
#include "postgres.h"
#else
#include "postgres_fe.h"
#endif

#include "common/unicode_case.h"
#include "common/unicode_case_table.h"
#include "common/unicode_category.h"
#include "mb/pg_wchar.h"

enum CaseMapResult
{
 CASEMAP_SELF,
 CASEMAP_SIMPLE,
 CASEMAP_SPECIAL,
};

/*
 * Map for each case kind.
 */
static const pg_wchar *const casekind_map[NCaseKind] =
{
 [CaseLower] = case_map_lower,
 [CaseTitle] = case_map_title,
 [CaseUpper] = case_map_upper,
 [CaseFold] = case_map_fold,
};

static pg_wchar find_case_map(pg_wchar ucs, const pg_wchar *map);
static size_t convert_case(char *dst, size_t dstsize, const char *src, ssize_t srclen,
         CaseKind str_casekind, bool full, WordBoundaryNext wbnext,
         void *wbstate);
static enum CaseMapResult casemap(pg_wchar u1, CaseKind casekind, bool full,
          const char *src, size_t srclen, size_t srcoff,
          pg_wchar *simple, const pg_wchar **special);

pg_wchar
unicode_lowercase_simple(pg_wchar code)
{
 pg_wchar cp = find_case_map(code, case_map_lower);

 return cp != 0 ? cp : code;
}

pg_wchar
unicode_titlecase_simple(pg_wchar code)
{
 pg_wchar cp = find_case_map(code, case_map_title);

 return cp != 0 ? cp : code;
}

pg_wchar
unicode_uppercase_simple(pg_wchar code)
{
 pg_wchar cp = find_case_map(code, case_map_upper);

 return cp != 0 ? cp : code;
}

pg_wchar
unicode_casefold_simple(pg_wchar code)
{
 pg_wchar cp = find_case_map(code, case_map_fold);

 return cp != 0 ? cp : code;
}

/*
 * unicode_strlower()
 *
 * Convert src to lowercase, and return the result length (not including
 * terminating NUL).
 *
 * String src must be encoded in UTF-8. If srclen < 0, src must be
 * NUL-terminated.
 *
 * Result string is stored in dst, truncating if larger than dstsize. If
 * dstsize is greater than the result length, dst will be NUL-terminated;
 * otherwise not.
 *
 * If dstsize is zero, dst may be NULL. This is useful for calculating the
 * required buffer size before allocating.
 *
 * If full is true, use special case mappings if available and if the
 * conditions are satisfied.
 */
size_t
unicode_strlower(char *dst, size_t dstsize, const char *src, ssize_t srclen,
     bool full)
{
 return convert_case(dst, dstsize, src, srclen, CaseLower, full, NULL,
      NULL);
}

/*
 * unicode_strtitle()
 *
 * Convert src to titlecase, and return the result length (not including
 * terminating NUL).
 *
 * String src must be encoded in UTF-8. If srclen < 0, src must be
 * NUL-terminated.
 *
 * Result string is stored in dst, truncating if larger than dstsize. If
 * dstsize is greater than the result length, dst will be NUL-terminated;
 * otherwise not.
 *
 * If dstsize is zero, dst may be NULL. This is useful for calculating the
 * required buffer size before allocating.
 *
 * If full is true, use special case mappings if available and if the
 * conditions are satisfied. Otherwise, use only simple mappings and use
 * uppercase instead of titlecase.
 *
 * Titlecasing requires knowledge about word boundaries, which is provided by
 * the callback wbnext. A word boundary is the offset of the start of a word
 * or the offset of the character immediately following a word.
 *
 * The caller is expected to initialize and free the callback state
 * wbstate. The callback should first return offset 0 for the first boundary;
 * then the offset of each subsequent word boundary; then the total length of
 * the string to indicate the final boundary.
 */
size_t
unicode_strtitle(char *dst, size_t dstsize, const char *src, ssize_t srclen,
     bool full, WordBoundaryNext wbnext, void *wbstate)
{
 return convert_case(dst, dstsize, src, srclen, CaseTitle, full, wbnext,
      wbstate);
}

/*
 * unicode_strupper()
 *
 * Convert src to uppercase, and return the result length (not including
 * terminating NUL).
 *
 * String src must be encoded in UTF-8. If srclen < 0, src must be
 * NUL-terminated.
 *
 * Result string is stored in dst, truncating if larger than dstsize. If
 * dstsize is greater than the result length, dst will be NUL-terminated;
 * otherwise not.
 *
 * If dstsize is zero, dst may be NULL. This is useful for calculating the
 * required buffer size before allocating.
 *
 * If full is true, use special case mappings if available and if the
 * conditions are satisfied.
 */
size_t
unicode_strupper(char *dst, size_t dstsize, const char *src, ssize_t srclen,
     bool full)
{
 return convert_case(dst, dstsize, src, srclen, CaseUpper, full, NULL,
      NULL);
}

/*
 * unicode_strfold()
 *
 * Case fold src, and return the result length (not including terminating
 * NUL).
 *
 * String src must be encoded in UTF-8. If srclen < 0, src must be
 * NUL-terminated.
 *
 * Result string is stored in dst, truncating if larger than dstsize. If
 * dstsize is greater than the result length, dst will be NUL-terminated;
 * otherwise not.
 *
 * If dstsize is zero, dst may be NULL. This is useful for calculating the
 * required buffer size before allocating.
 */
size_t
unicode_strfold(char *dst, size_t dstsize, const char *src, ssize_t srclen,
    bool full)
{
 return convert_case(dst, dstsize, src, srclen, CaseFold, full, NULL,
      NULL);
}

/*
 * Implement Unicode Default Case Conversion algorithm.
 *
 * If str_casekind is CaseLower or CaseUpper, map each character in the string
 * for which a mapping is available.
 *
 * If str_casekind is CaseTitle, maps characters found on a word boundary to
 * titlecase (or uppercase if full is false) and other characters to
 * lowercase. NB: does not currently implement the Unicode behavior in which
 * the word boundary is adjusted to the next Cased character. That behavior
 * could be implemented as an option, but it doesn't match the default
 * behavior of ICU, nor does it match the documented behavior of INITCAP().
 *
 * If full is true, use special mappings for relevant characters, which can
 * map a single codepoint to multiple codepoints, or depend on conditions.
 */
static size_t
convert_case(char *dst, size_t dstsize, const char *src, ssize_t srclen,
    CaseKind str_casekind, bool full, WordBoundaryNext wbnext,
    void *wbstate)
{
 /* character CaseKind varies while titlecasing */
 CaseKind chr_casekind = str_casekind;
 size_t  srcoff = 0;
 size_t  result_len = 0;
 size_t  boundary = 0;

 Assert((str_casekind == CaseTitle && wbnext && wbstate) ||
     (str_casekind != CaseTitle && !wbnext && !wbstate));

 if (str_casekind == CaseTitle)
 {
  boundary = wbnext(wbstate);
  Assert(boundary == 0); /* start of text is always a boundary */
 }

 while ((srclen < 0 || srcoff < srclen) && src[srcoff] != '\0')
 {
  pg_wchar u1 = utf8_to_unicode((unsigned char *) src + srcoff);
  int   u1len = unicode_utf8len(u1);
  pg_wchar simple = 0;
  const pg_wchar *special = NULL;
  enum CaseMapResult casemap_result;

  if (str_casekind == CaseTitle)
  {
   if (srcoff == boundary)
   {
    chr_casekind = full ? CaseTitle : CaseUpper;
    boundary = wbnext(wbstate);
   }
   else
    chr_casekind = CaseLower;
  }

  casemap_result = casemap(u1, chr_casekind, full, src, srclen, srcoff,
         &simple, &special);

  switch (casemap_result)
  {
   case CASEMAP_SELF:
    /* no mapping; copy bytes from src */
    Assert(simple == 0);
    Assert(special == NULL);
    if (result_len + u1len <= dstsize)
     memcpy(dst + result_len, src + srcoff, u1len);

    result_len += u1len;
    break;
   case CASEMAP_SIMPLE:
    {
     /* replace with single character */
     pg_wchar u2 = simple;
     pg_wchar u2len = unicode_utf8len(u2);

     Assert(special == NULL);
     if (result_len + u2len <= dstsize)
      unicode_to_utf8(u2, (unsigned char *) dst + result_len);

     result_len += u2len;
    }
    break;
   case CASEMAP_SPECIAL:
    /* replace with up to MAX_CASE_EXPANSION characters */
    Assert(simple == 0);
    for (int i = 0; i < MAX_CASE_EXPANSION && special[i]; i++)
    {
     pg_wchar u2 = special[i];
     size_t  u2len = unicode_utf8len(u2);

     if (result_len + u2len <= dstsize)
      unicode_to_utf8(u2, (unsigned char *) dst + result_len);

     result_len += u2len;
    }
    break;
  }

  srcoff += u1len;
 }

 if (result_len < dstsize)
  dst[result_len] = '\0';

 return result_len;
}

/*
 * Check that the condition matches Final_Sigma, described in Unicode Table
 * 3-17. The character at the given offset must be directly preceded by a
 * Cased character, and must not be directly followed by a Cased character.
 *
 * Case_Ignorable characters are ignored. NB: some characters may be both
 * Cased and Case_Ignorable, in which case they are ignored.
 */
static bool
check_final_sigma(const unsigned char *str, size_t len, size_t offset)
{
 /* the start of the string is not preceded by a Cased character */
 if (offset == 0)
  return false;

 /* iterate backwards, looking for Cased character */
 for (int i = offset - 1; i >= 0; i--)
 {
  if ((str[i] & 0x80) == 0 || (str[i] & 0xC0) == 0xC0)
  {
   pg_wchar curr = utf8_to_unicode(str + i);

   if (pg_u_prop_case_ignorable(curr))
    continue;
   else if (pg_u_prop_cased(curr))
    break;
   else
    return false;
  }
  else if ((str[i] & 0xC0) == 0x80)
   continue;

  Assert(false);   /* invalid UTF-8 */
 }

 /* end of string is not followed by a Cased character */
 if (offset == len)
  return true;

 /* iterate forwards, looking for Cased character */
 for (int i = offset + 1; i < len && str[i] != '\0'; i++)
 {
  if ((str[i] & 0x80) == 0 || (str[i] & 0xC0) == 0xC0)
  {
   pg_wchar curr = utf8_to_unicode(str + i);

   if (pg_u_prop_case_ignorable(curr))
    continue;
   else if (pg_u_prop_cased(curr))
    return false;
   else
    break;
  }
  else if ((str[i] & 0xC0) == 0x80)
   continue;

  Assert(false);   /* invalid UTF-8 */
 }

 return true;
}

/*
 * Unicode allows for special casing to be applied only under certain
 * circumstances. The only currently-supported condition is Final_Sigma.
 */
static bool
check_special_conditions(int conditions, const char *str, size_t len,
       size_t offset)
{
 if (conditions == 0)
  return true;
 else if (conditions == PG_U_FINAL_SIGMA)
  return check_final_sigma((unsigned char *) str, len, offset);

 /* no other conditions supported */
 Assert(false);
 return false;
}

/*
 * Map the given character to the requested case.
 *
 * If full is true, and a special case mapping is found and the conditions are
 * met, 'special' is set to the mapping result (which is an array of up to
 * MAX_CASE_EXPANSION characters) and CASEMAP_SPECIAL is returned.
 *
 * Otherwise, search for a simple mapping, and if found, set 'simple' to the
 * result and return CASEMAP_SIMPLE.
 *
 * If no mapping is found, return CASEMAP_SELF, and the caller should copy the
 * character without modification.
 */
static enum CaseMapResult
casemap(pg_wchar u1, CaseKind casekind, bool full,
  const char *src, size_t srclen, size_t srcoff,
  pg_wchar *simple, const pg_wchar **special)
{
 uint16  idx;

 /* Fast path for codepoints < 0x80 */
 if (u1 < 0x80)
 {
  /*
   * The first elements in all tables are reserved as 0 (as NULL). The
   * data starts at index 1, not 0.
 */
  *simple = casekind_map[casekind][u1 + 1];

  return CASEMAP_SIMPLE;
 }

 idx = case_index(u1);

 if (idx == 0)
  return CASEMAP_SELF;

 if (full && case_map_special[idx] &&
  check_special_conditions(special_case[case_map_special[idx]].conditions,
         src, srclen, srcoff))
 {
  *special = special_case[case_map_special[idx]].map[casekind];
  return CASEMAP_SPECIAL;
 }

 *simple = casekind_map[casekind][idx];

 return CASEMAP_SIMPLE;
}

/*
 * Find entry in simple case map.
 * If the entry does not exist, 0 will be returned.
 */
static pg_wchar
find_case_map(pg_wchar ucs, const pg_wchar *map)
{
 /* Fast path for codepoints < 0x80 */
 if (ucs < 0x80)
  /* The first elements in all tables are reserved as 0 (as NULL). */
  return map[ucs + 1];
 return map[case_index(ucs)];
}