#ifndef SQL_ITEM_REGEXP_FUNC_H_
#define SQL_ITEM_REGEXP_FUNC_H_

/* Copyright (c) 2017, 2025, Oracle and/or its affiliates.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License, version 2.0,
   as published by the Free Software Foundation.

   This program is designed to work with certain software (including
   but not limited to OpenSSL) that is licensed under separate terms,
   as designated in a particular file or component or in included license
   documentation.  The authors of MySQL hereby grant you an additional
   permission to link the program and your derivative works with the
   separately licensed software that they have either included with
   the program or referenced in the documentation.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License, version 2.0, for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */

/**
  @file item_regexp_func.h

  The function classes for regular expression functions. They have a common
  base class Item_func_regexp, which is also the prefix of their class
  names. After the %Item_func prefix comes the name of the SQL function,
  e.g. Item_func_regexp_instr represents the SQL function `REGEXP_INSTR`.

  Type resolution
  ===============

  The type and name resolution procedure is hooked into by the
  Item_func_regexp class, which implement both
  Item_result_field::resolve_type() and Item::fix_fields().

  Collations
  ==========

  The regular expression library doesn't deal with collations at all, but we
  need them because the 'winning' collation of the pattern and the subject
  strings dictates case-sensitivity. The winning collation is defined by
  coercion rules, and we don't delve into that here. See
  Item_func::agg_arg_charsets_for_comparison(). The call to this function is
  done in resolve_type() as this appears to be an unwritten convention.

  Implementation
  ==============

  All communication with the regular expression library is done through a
  Regexp_facade object, instantiated in Item_func_regexp::fix_fields().

  @todo We now clean up ICU heap memory in Item_func_regexp::cleanup. Should
  it be done more rarely? On session close?
*/

#include <assert.h>
#include <unicode/uregex.h>

#include <optional>
#include <string>

// assert
#include "my_inttypes.h"  // MY_INT32_NUM_DECIMAL_DIGITS
#include "mysql/strings/m_ctype.h"
#include "sql/item_cmpfunc.h"
#include "sql/item_strfunc.h"
#include "sql/mysqld.h"  // make_unique_destroy_only
#include "sql/regexp/regexp_facade.h"
#include "sql_string.h"  // String

// GCC bug 80635.
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif

/**
  Base class for all regular expression function classes. Is responsible for
  creating the Regexp_facade object.
*/
class Item_func_regexp : public Item_func {
 public:
  Item_func_regexp(const POS &pos, PT_item_list *opt_list)
      : Item_func(pos, opt_list) {}

  /**
    Resolves the collation to use for comparison. The type resolution is done
    in the subclass constructors.

    For all regular expression functions, i.e. REGEXP_INSTR, REGEXP_LIKE,
    REGEXP_REPLACE and REGEXP_SUBSTR, it goes that the first two arguments
    have to agree on a common collation. This collation is used to control
    case-sensitivity.

    @see fix_fields()
  */
  bool resolve_type(THD *) override;

  /// Decides on the mode for matching, case sensitivity etc.
  bool fix_fields(THD *thd, Item **) override;

  /// The expression for the subject string.
  Item *subject() const { return args[0]; }

  /// The expression for the pattern string.
  Item *pattern() const { return args[1]; }

  /// The value of the `position` argument, or its default if absent.
  std::optional<int> position() const {
    const int the_index = pos_arg_pos();
    if (the_index != -1 && arg_count >= static_cast<uint>(the_index) + 1) {
      const int value = args[the_index]->val_int();
      /*
        Note: Item::null_value() can't be trusted alone here; there are cases
        (for the DATE data type in particular) where we can have it set
        without Item::m_nullable being set! This really should be cleaned up,
        but until that happens, we need to have a more conservative check.
      */
      if (args[the_index]->is_nullable() && args[the_index]->null_value)
        return {};
      else
        return value;
    }
    return 1;
  }

  /// The value of the `occurrence` argument, or its default if absent.
  std::optional<int> occurrence() const {
    const int the_index = occ_arg_pos();
    if (the_index != -1 && arg_count >= static_cast<uint>(the_index) + 1) {
      const int value = args[the_index]->val_int();
      /*
        Note: Item::null_value() can't be trusted alone here; there are cases
        (for the DATE data type in particular) where we can have it set
        without Item::maybe_null being set! This really should be cleaned up,
        but until that happens, we need to have a more conservative check.
      */
      if (args[the_index]->is_nullable() && args[the_index]->null_value)
        return {};
      else
        return value;
    }
    return 0;
  }

  /// The value of the `match_parameter` argument, or an empty string if absent.
  std::optional<std::string> match_parameter() const {
    const int the_index = match_arg_pos();
    if (the_index != -1 && arg_count >= static_cast<uint>(the_index) + 1) {
      StringBuffer<5> buf;  // Longer match_parameter doesn't make sense.
      String *s = args[the_index]->val_str(&buf);
      if (s != nullptr)
        return to_string(*s);
      else
        return {};
    }
    return std::string{};
  }

  void cleanup() override;

 protected:
  String *convert_int_to_str(String *str) {
    assert(fixed);
    longlong nr = val_int();
    if (null_value) return nullptr;
    str->set_int(nr, unsigned_flag, collation.collation);
    return str;
  }

  my_decimal *convert_int_to_decimal(my_decimal *value) {
    assert(fixed);
    longlong nr = val_int();
    if (null_value) return nullptr; /* purecov: inspected */
    int2my_decimal(E_DEC_FATAL_ERROR, nr, unsigned_flag, value);
    return value;
  }

  double convert_int_to_real() {
    assert(fixed);
    return val_int();
  }

  double convert_str_to_real() {
    assert(fixed);
    int err_not_used;
    const char *end_not_used;
    String *res = val_str(&str_value);
    if (res == nullptr) return 0.0;
    return my_strntod(res->charset(), res->ptr(), res->length(), &end_not_used,
                      &err_not_used);
  }

  longlong convert_str_to_int() {
    assert(fixed);
    int err;
    String *res = val_str(&str_value);
    if (res == nullptr) return 0;
    return my_strntoll(res->charset(), res->ptr(), res->length(), 10, nullptr,
                       &err);
  }

  /**
    The position in the argument list of 'position'. -1 means that the default
    should be used.
  */
  virtual int pos_arg_pos() const = 0;

  /**
    The position in the argument list of 'occurrence'. -1 means that the default
    should be used.
  */
  virtual int occ_arg_pos() const = 0;

  /// The position in the argument list of match_parameter.
  virtual int match_arg_pos() const = 0;

  bool set_pattern();

  unique_ptr_destroy_only<regexp::Regexp_facade> m_facade;
};

class Item_func_regexp_instr : public Item_func_regexp {
 public:
  Item_func_regexp_instr(const POS &pos, PT_item_list *opt_list)
      : Item_func_regexp(pos, opt_list) {
    set_data_type_longlong();
  }

  Item_result result_type() const override { return INT_RESULT; }

  bool fix_fields(THD *thd, Item **arguments) override;

  String *val_str(String *str) override { return convert_int_to_str(str); }

  double val_real() override { return convert_int_to_real(); }

  longlong val_int() override;

  const char *func_name() const override { return "regexp_instr"; }

  /// The value of the `return_option` argument, or its default if absent.
  std::optional<int> return_option() const {
    const int the_index = retopt_arg_pos();
    if (the_index != -1 && arg_count >= static_cast<uint>(the_index) + 1) {
      const int value = args[the_index]->val_int();
      if (args[the_index]->null_value || current_thd->is_error())
        return std::optional<int>();
      else
        return value;
    }
    return 0;
  }

  /**
    @{

    Copy-pasted from Item_int_func. Usually, an SQL function returning INTEGER
    just inherits Item_int_func and thus the implementation, but these classes
    need to have Item_func_regexp as base class because of fix_fields().
  */
  bool val_date(Date_val *date, my_time_flags_t flags) override {
    return get_date_from_int(date, flags);
  }
  bool val_time(Time_val *time) override { return get_time_from_int(time); }
  bool val_datetime(Datetime_val *dt, my_time_flags_t flags) override {
    return get_datetime_from_int(dt, flags);
  }
  /// @}

 protected:
  int pos_arg_pos() const override { return 2; }
  int occ_arg_pos() const override { return 3; }
  /// The position in the argument list of `occurrence`.
  int retopt_arg_pos() const { return 4; }
  int match_arg_pos() const override { return 5; }

 private:
  bool resolve_type(THD *) final;
};

class Item_func_regexp_like : public Item_func_regexp {
 public:
  Item_func_regexp_like(const POS &pos, PT_item_list *opt_list)
      : Item_func_regexp(pos, opt_list) {
    set_data_type_bool();
  }

  Item_result result_type() const override { return INT_RESULT; }

  String *val_str(String *str) override { return convert_int_to_str(str); }

  double val_real() override { return convert_int_to_real(); }

  longlong val_int() override;

  const char *func_name() const override { return "regexp_like"; }

  bool is_bool_func() const override { return true; }

  /**
    @{

    Copy-pasted from Item_int_func. Usually, an SQL function returning INTEGER
    just inherits Item_int_func and thus the implementation, but these classes
    need to have Item_func_regexp as base class because of fix_fields().
  */
  bool val_date(Date_val *date, my_time_flags_t flags) override {
    return get_date_from_int(date, flags);
  }
  bool val_time(Time_val *time) override { return get_time_from_int(time); }
  bool val_datetime(Datetime_val *dt, my_time_flags_t flags) override {
    return get_datetime_from_int(dt, flags);
  }
  /// @}

 protected:
  int pos_arg_pos() const override { return -1; }
  int occ_arg_pos() const override { return -1; }
  int match_arg_pos() const override { return 2; }

 private:
  bool resolve_type(THD *) final;
};

class Item_func_regexp_replace : public Item_func_regexp {
 public:
  Item_func_regexp_replace(const POS &pos, PT_item_list *item_list)
      : Item_func_regexp(pos, item_list) {}

  Item_result result_type() const override { return STRING_RESULT; }

  bool resolve_type(THD *) final;

  Item *replacement() { return args[2]; }

  longlong val_int() override { return convert_str_to_int(); }

  String *val_str(String *result) override;

  double val_real() override { return convert_str_to_real(); }

  const char *func_name() const override { return "regexp_replace"; }

  /**
    @{

    Copy-pasted from Item_str_func. Usually, an SQL function returning INTEGER
    just inherits Item_str_func and thus the implementation, but these classes
    need to have Item_func_regexp as base class because of fix_fields().
  */
  bool val_date(Date_val *date, my_time_flags_t flags) override {
    return get_date_from_string(date, flags);
  }
  bool val_time(Time_val *time) override { return get_time_from_string(time); }
  bool val_datetime(Datetime_val *dt, my_time_flags_t flags) override {
    return get_datetime_from_string(dt, flags);
  }
  /// @}

 protected:
  int pos_arg_pos() const override { return 3; }
  int occ_arg_pos() const override { return 4; }
  int match_arg_pos() const override { return 5; }
};

class Item_func_regexp_substr : public Item_func_regexp {
 public:
  Item_func_regexp_substr(const POS &pos, PT_item_list *item_list)
      : Item_func_regexp(pos, item_list) {}

  Item_result result_type() const override { return STRING_RESULT; }

  bool resolve_type(THD *) final;

  longlong val_int() override { return convert_str_to_int(); }

  String *val_str(String *result) override;

  double val_real() override { return convert_str_to_real(); }

  const char *func_name() const override { return "regexp_substr"; }

  /**
    @{

    Copy-pasted from Item_str_func. Usually, an SQL function returning INTEGER
    just inherits Item_str_func and thus the implementation, but these classes
    need to have Item_func_regexp as base class because of fix_fields().
  */
  bool val_date(Date_val *date, my_time_flags_t flags) override {
    return get_date_from_string(date, flags);
  }
  bool val_time(Time_val *time) override { return get_time_from_string(time); }
  bool val_datetime(Datetime_val *dt, my_time_flags_t flags) override {
    return get_datetime_from_string(dt, flags);
  }
  /// @}

 protected:
  int pos_arg_pos() const override { return 2; }
  int occ_arg_pos() const override { return 3; }
  int match_arg_pos() const override { return 4; }
};

class Item_func_icu_version final : public Item_static_string_func {
  using super = Item_static_string_func;

 public:
  explicit Item_func_icu_version(const POS &pos);

  bool do_itemize(Parse_context *pc, Item **res) override;
};

#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif

#endif  // SQL_ITEM_REGEXP_FUNC_H_
