/**
 * Copyright (c) 2021 OceanBase
 * OceanBase CE is licensed under Mulan PubL v2.
 * You can use this software according to the terms and conditions of the Mulan PubL v2.
 * You may obtain a copy of Mulan PubL v2 at:
 *          http://license.coscl.org.cn/MulanPubL-2.0
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 * See the Mulan PubL v2 for more details.
 */

#define USING_LOG_PREFIX SQL_ENG
#define OB_MAX_WEIGHT  OB_MAX_VARCHAR_LENGTH

#include <string.h>
#include "objit/common/ob_item_type.h"
#include "sql/engine/expr/ob_expr_weight_string.h"
#include "sql/engine/expr/ob_expr_operator.h"
#include "share/object/ob_obj_cast.h"
#include "lib/oblog/ob_log.h"
#include "sql/engine/expr/ob_datum_cast.h"
#include "ob_expr_util.h"
#include "sql/engine/ob_exec_context.h"
#include "sql/session/ob_sql_session_info.h"

using namespace oceanbase::common;

namespace oceanbase
{
namespace sql
{
ObExprWeightString::ObExprWeightString(ObIAllocator &alloc)
    : ObStringExprOperator(alloc, T_FUN_SYS_WEIGHT_STRING, N_WEIGHT_STRING, MORE_THAN_ZERO, NOT_VALID_FOR_GENERATED_COL)
{
}
ObExprWeightString::~ObExprWeightString()
{
}
int ObExprWeightString::calc_result_typeN(ObExprResType &type,
                                          ObExprResType *types_stack,
                                          int64_t param_num,
                                          ObExprTypeCtx &type_ctx) const
{
  int ret = OB_SUCCESS;
  UNUSED(param_num);
  CK (OB_NOT_NULL(type_ctx.get_session()));
  if (NOT_ROW_DIMENSION != row_dimension_ || ObMaxType == types_stack[0].get_type()) {
    ret = OB_ERR_INVALID_TYPE_FOR_OP;
  } else {
    uint64_t max_length = OB_MAX_VARBINARY_LENGTH; // The maximum length of the result of WEIGHT_STRING()
    uint64_t result_length = types_stack[1].get_param().get_int();
    uint64_t nweight = types_stack[2].get_param().get_int();
    bool as_binary = types_stack[4].get_param().get_int();
    ObCollationLevel coll_level = CS_LEVEL_INVALID;
    if (as_binary) {
      coll_level = CS_LEVEL_IMPLICIT;
      type_ctx.set_cast_mode(type_ctx.get_cast_mode() | CM_NULL_ON_WARN);
      types_stack[0].set_calc_type(ObVarcharType);
    } else {
      coll_level = types_stack[0].get_collation_level();
      if (types_stack[0].get_type() > ObUNumberType &&
          types_stack[0].get_type() != ObBitType &&
          types_stack[0].get_type() != ObYearType) {
        // When the input is not a numeric type, convert to a varchar type
        type_ctx.set_cast_mode(type_ctx.get_cast_mode() | CM_NULL_ON_WARN);
        types_stack[0].set_calc_type(ObVarcharType);
      }
    }
    ObCollationType collation_type = types_stack[0].get_collation_type();
    const ObCharsetInfo *cs = ObCharset::get_charset(collation_type); 
    if (types_stack[0].get_type() == ObDateTimeType ||
        types_stack[0].get_type() == ObTimestampType || 
        types_stack[0].get_type() == ObDateType ||
        types_stack[0].get_type() == ObTimeType ) {
      // For types such as date, time, etc., the max_lenght is the length of the type entered
      max_length = types_stack[0].get_length();
    } else if (result_length > 0) {
      max_length = result_length;
    } else if (as_binary) {
      // In the case of as_binary, the max_length with nweight as the output result
      max_length = nweight; 
    } else {
      // If the input is others, use cs->mbmaxlen to calculate the max_length
      max_length = cs->mbmaxlen * MAX(nweight, types_stack[0].get_length()*cs->mbmaxlen);
    }
    type.set_varchar();
    type.set_collation_type(CS_TYPE_BINARY);
    type.set_collation_level(coll_level);
    type.set_length(max_length);
  }
  return ret;
}

int ObExprWeightString::eval_weight_string(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &res_datum)
{
  int ret = OB_SUCCESS;
  ObDatum *arg = NULL;
  ObDatum *result_length_arg = NULL;
  ObDatum *nweights_arg = NULL;
  ObDatum *flags_arg = NULL;
  ObDatum *as_binary_arg = NULL;
  if (OB_FAIL(expr.args_[0]->eval(ctx, arg)) ||
      OB_FAIL(expr.args_[1]->eval(ctx, result_length_arg)) ||
      OB_FAIL(expr.args_[2]->eval(ctx, nweights_arg)) ||
      OB_FAIL(expr.args_[3]->eval(ctx, flags_arg)) ||
      OB_FAIL(expr.args_[4]->eval(ctx, as_binary_arg))) {
    LOG_WARN("eval arg failed", K(ret), 
                                KP(arg),
                                KP(result_length_arg),
                                KP(nweights_arg),
                                KP(flags_arg),
                                KP(as_binary_arg));
  } else {
    const ObString str = arg->get_string();
    uint64_t result_length = result_length_arg->get_int();
    uint64_t nweights = nweights_arg->get_int();
    uint64_t flags = flags_arg->get_int();
    bool as_binary = as_binary_arg->get_int();
    int64_t max_allowed_packet = 0;
    ObSQLSessionInfo *session = ctx.exec_ctx_.get_my_session();
    if (arg->is_null()) {
      res_datum.set_null();
    } else if (!as_binary && (expr.args_[0]->datum_meta_.type_ <= ObUNumberType ||
                              expr.args_[0]->datum_meta_.type_ == ObBitType ||
                              expr.args_[0]->datum_meta_.type_ == ObYearType)) {
      res_datum.set_null();
    } else if (arg->get_string().empty() && nweights == 0) {
      res_datum.set_string(nullptr,0);
    } else {
      if (OB_FAIL(session->get_max_allowed_packet(max_allowed_packet))) {
        if (OB_ENTRY_NOT_EXIST == ret) {
          ret = OB_SUCCESS;
          max_allowed_packet = OB_MAX_VARCHAR_LENGTH;
        } else {
          LOG_WARN("Failed to get max allow packet size", K(ret));
        }
      }
      // Get the character set and collation information of the input string
      ObCollationType collation_type = CS_TYPE_INVALID;
      if (as_binary) {
        collation_type  = CS_TYPE_BINARY;
      } else {
        collation_type = expr.args_[0]->datum_meta_.cs_type_;
      }
      const ObCharsetInfo *cs = ObCharset::get_charset(collation_type);
      flags = ob_strxfrm_flag_normalize(flags, cs->levels_for_order);
      // calc the length of result
      size_t frm_length = 0;
      size_t tmp_length = 0;
      if (result_length > 0) {
        tmp_length = result_length;
      } else {
        tmp_length = cs->coll->strnxfrmlen(cs, cs->mbmaxlen*MAX(str.length() , nweights));
      }
      if (tmp_length >= max_allowed_packet) {
        // The return result exceeds the maximum limit and returns NULL.
        res_datum.set_null();
      } else {
        int used_nweights = nweights;
        size_t input_length = str.length();
        if (used_nweights) {
          //truncate input string
          input_length = std::min(input_length, cs->cset->charpos(cs, str.ptr(), str.ptr() + str.length(), nweights));
        } else {
          //calc char length
          used_nweights = cs->cset->numchars(cs, str.ptr(), str.ptr() + str.length());
        }
        bool is_valid_unicode_tmp = 1;
        char *out_buf = expr.get_str_res_mem(ctx, tmp_length);
        // For the case where the input is an empty string but the nweight is not 0,
        // the weight_string function will call strnxfrm() to padding the result
        // eg:
        // mysql> select HEX(WEIGHT_STRING('' as char(3)));
        // +-----------------------------------+
        // | HEX(WEIGHT_STRING('' as char(3))) |
        // +-----------------------------------+
        // | 002000200020                      |
        // +-----------------------------------+
        // However, the strnxfrm requires that the input cannot be a null ptr,
        // so an empty string is set as the input.
        const char* tmp_empty_str = "";
        if (OB_ISNULL(out_buf)) {
          ret = OB_ALLOCATE_MEMORY_FAILED;
          LOG_WARN("failed to alloc output buf",K(ret));
        } else {
          frm_length = cs->coll->strnxfrm(cs,
                                        reinterpret_cast<uchar *>(out_buf),
                                        tmp_length,
                                        used_nweights,
                                        str.ptr() != NULL? reinterpret_cast<const uchar *>(str.ptr()) : reinterpret_cast<const uchar *>(tmp_empty_str),
                                        input_length,
                                        flags,
                                        &is_valid_unicode_tmp);
          res_datum.set_string(out_buf,frm_length);
        }
      }
    }
  }
  return ret;
}

int ObExprWeightString::cg_expr(ObExprCGCtx &op_cg_ctx, const ObRawExpr &raw_expr,
    ObExpr &rt_expr) const
{
  UNUSED(op_cg_ctx);
  UNUSED(raw_expr);
  rt_expr.eval_func_ = ObExprWeightString::eval_weight_string;
  return OB_SUCCESS;
}

uint64_t ObExprWeightString::ob_strxfrm_flag_normalize(uint64_t flags, uint64_t maximum)
{
   /* If levels are omitted, then 1-maximum is assumed*/
  if (!(flags & OB_STRXFRM_LEVEL_ALL)) {
    static uint64_t def_level_flags[]= {0, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F };
    uint64_t flag_pad= flags & (OB_STRXFRM_PAD_WITH_SPACE | OB_STRXFRM_PAD_TO_MAXLEN);
    flags= def_level_flags[maximum] | flag_pad;
  }
  else {
    uint64_t i = 0;
    uint64_t flag_lev= flags & OB_STRXFRM_LEVEL_ALL;
    uint64_t flag_dsc= (flags >> OB_STRXFRM_DESC_SHIFT) & OB_STRXFRM_LEVEL_ALL;
    uint64_t flag_rev= (flags >> OB_STRXFRM_REVERSE_SHIFT) & OB_STRXFRM_LEVEL_ALL;
    uint64_t flag_pad= flags & (OB_STRXFRM_PAD_WITH_SPACE | OB_STRXFRM_PAD_TO_MAXLEN);
    /*
      If any level number is greater than the maximum,
      it is treated as the maximum.
    */
    maximum--;
    flags= 0;
    for (i= 0; i < OB_STRXFRM_NLEVELS; i++)
    {
      uint64_t src_bit= 1 << i;
      if (flag_lev & src_bit) {
        uint64_t dst_bit= 1 << OB_MIN(i, maximum);
        flags|= dst_bit;
        flags|= (flag_dsc & dst_bit) << OB_STRXFRM_DESC_SHIFT;
        flags|= (flag_rev & dst_bit) << OB_STRXFRM_REVERSE_SHIFT;
      }
    }
    flags|= flag_pad;
  }
  return flags;
}


}
}