/**
 * 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

#include "sql/engine/expr/ob_expr_autoinc_nextval.h"
#include "lib/mysqlclient/ob_mysql_result.h"
#include "sql/engine/ob_physical_plan_ctx.h"
#include "sql/session/ob_sql_session_info.h"
#include "sql/engine/ob_exec_context.h"

namespace oceanbase {
using namespace common;
using namespace share;
namespace sql {
ObExprAutoincNextval::ObExprAutoincNextval(ObIAllocator& alloc)
    : ObFuncExprOperator(alloc, T_FUN_SYS_AUTOINC_NEXTVAL, N_AUTOINC_NEXTVAL, ONE_OR_TWO, NOT_ROW_DIMENSION)
{
  disable_operand_auto_cast();
}

ObExprAutoincNextval::~ObExprAutoincNextval()
{}

int ObExprAutoincNextval::calc_result_typeN(
    ObExprResType& type, ObExprResType* types_array, int64_t param_num, ObExprTypeCtx& type_ctx) const
{
  int ret = OB_SUCCESS;
  type.set_uint64();
  type.set_scale(ObAccuracy::DDL_DEFAULT_ACCURACY[ObUInt64Type].scale_);
  type.set_precision(ObAccuracy::DDL_DEFAULT_ACCURACY[ObUInt64Type].precision_);
  type.set_result_flag(OB_MYSQL_NOT_NULL_FLAG);

  CK(NULL != type_ctx.get_session());
  if (OB_SUCC(ret) && type_ctx.get_session()->use_static_typing_engine()) {
    CK(types_array[0].is_uint64());
    if (OB_SUCC(ret) && 2 == param_num) {
      // column_conv() is add before nextval() in static tying engine. Parameter 2 is converted
      // to defined type, only int/uint/float/double allowed.
      ObObjTypeClass tc = ob_obj_type_class(type.get_type());
      if (!(ObNullTC == tc || ObIntTC == tc || ObUIntTC == tc || ObFloatTC == tc || ObDoubleTC == tc)) {
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("only int/uint/float/double type class supported for auto_increment column", K(ret));
      } else {
        static_cast<ObObjMeta&>(type) = types_array[1];
      }
    }
  }

  return ret;
}

int ObExprAutoincNextval::calc_resultN(
    ObObj& result, const ObObj* objs_array, int64_t param_num, ObExprCtx& expr_ctx) const
{
  int ret = OB_SUCCESS;
  if (OB_UNLIKELY(1 != param_num && 2 != param_num) || OB_ISNULL(objs_array) || OB_ISNULL(expr_ctx.phy_plan_ctx_) ||
      OB_UNLIKELY(!objs_array[0].is_uint64())) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("Invalid argument(s)", K(ret), K(objs_array), K(param_num), K(objs_array), K(expr_ctx.phy_plan_ctx_));
  } else {
    ObAutoincrementService& auto_service = ObAutoincrementService::get_instance();
    ObPhysicalPlanCtx* plan_ctx = expr_ctx.phy_plan_ctx_;
    ObIArray<AutoincParam>& autoinc_params = plan_ctx->get_autoinc_params();
    bool is_to_generate = false;
    AutoincParam* autoinc_param = NULL;
    uint64_t autoinc_col_id = objs_array[0].get_uint64();
    for (int64_t i = 0; OB_SUCC(ret) && i < autoinc_params.count(); ++i) {
      if (autoinc_col_id == autoinc_params.at(i).autoinc_col_id_) {
        autoinc_param = &(autoinc_params.at(i));
        break;
      }
    }
    // this column with column_index is auto-increment column
    if (OB_ISNULL(autoinc_param)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("should find auto-increment param", K(ret));
    }

    // sync last user specified value first(compatible with MySQL)
    if (OB_SUCC(ret)) {
      if (OB_FAIL(auto_service.sync_insert_value_local(*autoinc_param))) {
        LOG_WARN("failed to sync last insert value", K(ret));
      }
    }

    uint64_t casted_value = 0;
    if (OB_SUCC(ret)) {
      uint64_t new_val = 0;
      // check : to generate auto-increment value or not
      if (OB_FAIL(
              check_and_cast(result, objs_array, param_num, expr_ctx, autoinc_param, is_to_generate, casted_value))) {
        LOG_WARN("check generation failed", K(ret));

      } else if (is_to_generate && OB_FAIL(generate_autoinc_value(new_val, auto_service, autoinc_param, plan_ctx))) {
        LOG_WARN("generate autoinc value failed", K(ret));
      } else if (is_to_generate) {
        result.set_uint64(new_val);
      }
    }

    if (OB_SUCC(ret)) {
      if (autoinc_param->autoinc_desired_count_ > 0) {
        --autoinc_param->autoinc_desired_count_;
      }

      if (OB_HIDDEN_PK_INCREMENT_COLUMN_ID != autoinc_param->autoinc_col_id_) {
        if (is_to_generate) {
          plan_ctx->set_autoinc_col_value(result.get_uint64());
        } else {
          plan_ctx->set_autoinc_col_value(casted_value);
        }
      }
    }
  }
  return ret;
}

// check generate auto-inc value or not and cast.
int ObExprAutoincNextval::check_and_cast(ObObj& result, const ObObj* objs_array, int64_t param_num, ObExprCtx& expr_ctx,
    AutoincParam* autoinc_param, bool& is_to_generate, uint64_t& casted_value)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(autoinc_param) || OB_ISNULL(expr_ctx.my_session_) || OB_ISNULL(objs_array)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("Invalid argument(s)", K(ret));
  } else if (1 == param_num) {
    is_to_generate = true;
  } else if (2 == param_num) {
    expr_ctx.cast_mode_ &= ~(CM_WARN_ON_FAIL);
    EXPR_DEFINE_CAST_CTX(expr_ctx, CM_NONE);
    const ObObj& param = objs_array[1];
    if (param.is_null()) {
      is_to_generate = true;
    } else if (!(SMO_NO_AUTO_VALUE_ON_ZERO & expr_ctx.my_session_->get_sql_mode())) {
      // generate value on zero
      if (param.is_zero()) {
        is_to_generate = true;
      } else {
        EXPR_GET_UINT64_V2(param, casted_value);
        if (OB_SUCC(ret)) {
          if (0 == casted_value) {
            // casted to zero; generate auto-increment value too
            is_to_generate = true;
          }
        } else {
          // the code "EXPR_GET_UINT64_V2(param, casted_value)" above is wrong,
          // auto increment column can be int or double in mysql, the correct operation
          // should be:
          // 1. cast param to column type, not the hard-coding 'uint'.
          // 2. if cast failed and sql mode is non-strict, set is_to_generate to true.
          //
          // cases below are all in non-strict mode.
          //
          // case 1:
          // column c1 is tinyint auto increment without unsigned, then insert -12 into c1.
          // -12 should be casted to tinyint or int, and we will not generate next value.
          // but we try to cast -12 to uint and get an error, we MUST NOT set is_to_generate
          // to true below.
          //
          // case 2:
          // column c1 is tinyint auto increment without unsigned, then insert 'abc' into c1.
          // try to cast 'abc' to tinyint or uint will always throw an error, but this time
          // we MUST set is_to_generate to true to generate nextval.
          //
          // so I removed the condition 'is_strict_mode(expr_ctx.my_session_->get_sql_mode())'
          // below, until we cast param to column type.

          if (autoinc_param->is_ignore_ || false /*!is_strict_mode(expr_ctx.my_session_->get_sql_mode())*/) {
            is_to_generate = true;
          }
        }
      }
    }  // end else if

    // do not generate; sync value specified by user
    if (OB_SUCC(ret)) {
      if (!is_to_generate) {
        result = param;
        // sync value
        if (0 == casted_value) {
          EXPR_GET_UINT64_V2(param, casted_value);
        }
        if (OB_SUCC(ret)) {
          if (casted_value > autoinc_param->value_to_sync_) {
            autoinc_param->value_to_sync_ = casted_value;
            autoinc_param->sync_flag_ = true;
          }
        }
      }
    }
    // failed to cast; keep original value
    if (OB_FAIL(ret)) {
      result = param;
      ret = OB_SUCCESS;
      // sync value 0 (no use here)
      autoinc_param->value_to_sync_ = 0;
      autoinc_param->sync_flag_ = true;
    }
  } else {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("Error unexpected", K(ret), K(param_num));
  }
  return ret;
}

int ObExprAutoincNextval::get_uint_value(
    const ObExpr& input_expr, ObDatum* input_value, bool& is_zero, uint64_t& casted_value)
{
  int ret = OB_SUCCESS;
  if (NULL == input_value || input_value->is_null()) {
    is_zero = true;
    casted_value = 0;
  } else {
    ObObjTypeClass tc = ob_obj_type_class(input_expr.datum_meta_.type_);
    switch (tc) {
      case ObIntTC: {
        is_zero = 0 == input_value->get_int();
        casted_value = input_value->get_int() < 0 ? 0 : input_value->get_int();
        break;
      }
      case ObUIntTC: {
        is_zero = 0 == input_value->get_uint();
        casted_value = input_value->get_uint();
        break;
      }
      case ObFloatTC: {
        is_zero = 0 == input_value->get_float();
        if (input_value->get_float() > 0) {
          casted_value = static_cast<uint64_t>(input_value->get_float() + 0.5);
        } else {
          casted_value = 0;
        }
        break;
      }
      case ObDoubleTC: {
        is_zero = 0 == input_value->get_double();
        if (input_value->get_double() > 0) {
          casted_value = static_cast<uint64_t>(input_value->get_double() + 0.5);
        } else {
          casted_value = 0;
        }
        break;
      }
      default:
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("only int/float/double types support auto increment", K(ret), K(input_expr.datum_meta_));
    }
  }
  return ret;
}

int ObExprAutoincNextval::get_input_value(const ObExpr& input_expr, ObEvalCtx& ctx, ObDatum* input_value,
    share::AutoincParam& autoinc_param, bool& is_to_generate, uint64_t& casted_value)
{
  int ret = OB_SUCCESS;
  if (NULL == input_value || input_value->is_null()) {
    is_to_generate = true;
  } else {
    bool is_zero = false;
    if (OB_FAIL(get_uint_value(input_expr, input_value, is_zero, casted_value))) {
      LOG_WARN("get casted unsigned int value failed", K(ret));
    }
    if (OB_SUCC(ret)) {
      if (!(SMO_NO_AUTO_VALUE_ON_ZERO & ctx.exec_ctx_.get_my_session()->get_sql_mode())) {
        if (is_zero) {
          is_to_generate = true;
        }
      }
    }
  }

  // do not generate; sync value specified by user
  if (OB_SUCC(ret)) {
    if (!is_to_generate) {
      if (casted_value > autoinc_param.value_to_sync_) {
        autoinc_param.value_to_sync_ = casted_value;
        autoinc_param.sync_flag_ = true;
      }
    }
  }
  return ret;
}

int ObExprAutoincNextval::generate_autoinc_value(
    uint64_t& new_val, ObAutoincrementService& auto_service, AutoincParam* autoinc_param, ObPhysicalPlanCtx* plan_ctx)
{
  int ret = OB_SUCCESS;
  if (OB_ISNULL(autoinc_param) || OB_ISNULL(plan_ctx)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("Invalid argument(s)", K(ret), K(autoinc_param), K(plan_ctx));
  } else {
    // sync insert value globally before sync value globally
    if (OB_FAIL(auto_service.sync_insert_value_global(*autoinc_param))) {
      LOG_WARN("failed to sync insert value globally", K(ret));
    }
    if (OB_SUCC(ret)) {
      uint64_t value = 0;
      CacheHandle*& cache_handle = autoinc_param->cache_handle_;
      // get cache handle when allocate first auto-increment value
      if (OB_ISNULL(cache_handle)) {
        if (OB_FAIL(auto_service.get_handle(*autoinc_param, cache_handle))) {
          LOG_WARN("failed to get auto_increment handle", K(ret));
        } else if (OB_ISNULL(cache_handle)) {
          ret = OB_ERR_UNEXPECTED;
          LOG_WARN("Error unexpceted", K(ret), K(cache_handle));
        }
      }

      if (OB_SUCC(ret)) {
        // get auto-increment value
        if (OB_FAIL(cache_handle->next_value(value))) {
          LOG_DEBUG("failed to get auto_increment value", K(ret), K(value));
          // release handle No.1
          auto_service.release_handle(cache_handle);
          // invalid cache handle; record count
          ++autoinc_param->autoinc_intervals_count_;
          if (OB_FAIL(auto_service.get_handle(*autoinc_param, cache_handle))) {
            LOG_WARN("failed to get auto_increment handle", K(ret));
          } else if (OB_FAIL(cache_handle->next_value(value))) {
            LOG_WARN("failed to get auto_increment value", K(ret));
          }
        }
      }

      if (OB_SUCC(ret)) {
        new_val = value;
        if (OB_HIDDEN_PK_INCREMENT_COLUMN_ID != autoinc_param->autoinc_col_id_) {
          plan_ctx->set_autoinc_id_tmp(value);
        }
      }
    }
  }
  return ret;
}

int ObExprAutoincNextval::cg_expr(ObExprCGCtx&, const ObRawExpr&, ObExpr& rt_expr) const
{
  int ret = OB_SUCCESS;
  CK(1 == rt_expr.arg_cnt_ || 2 == rt_expr.arg_cnt_);
  rt_expr.eval_func_ = eval_nextval;
  return ret;
}

int ObExprAutoincNextval::eval_nextval(const ObExpr& expr, ObEvalCtx& ctx, ObDatum& expr_datum)
{
  int ret = OB_SUCCESS;
  ObDatum* col_id = NULL;
  ObDatum* input_value = NULL;
  ObPhysicalPlanCtx* plan_ctx = ctx.exec_ctx_.get_physical_plan_ctx();
  if (OB_ISNULL(plan_ctx)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("no phy plan context", K(ret));
  } else if (OB_FAIL(expr.eval_param_value(ctx, col_id, input_value))) {
    LOG_WARN("evaluate parameter failed", K(ret));
  } else if (col_id->is_null()) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("id is null", K(ret));
  } else {
    ObAutoincrementService& auto_service = ObAutoincrementService::get_instance();
    ObIArray<AutoincParam>& autoinc_params = plan_ctx->get_autoinc_params();
    bool is_to_generate = false;
    AutoincParam* autoinc_param = NULL;
    uint64_t autoinc_col_id = col_id->get_uint();
    for (int64_t i = 0; OB_SUCC(ret) && i < autoinc_params.count(); ++i) {
      if (autoinc_col_id == autoinc_params.at(i).autoinc_col_id_) {
        autoinc_param = &(autoinc_params.at(i));
        break;
      }
    }
    // this column with column_index is auto-increment column
    if (OB_ISNULL(autoinc_param)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("should find auto-increment param", K(ret));
    }

    // sync last user specified value first(compatible with MySQL)
    if (OB_SUCC(ret)) {
      if (OB_FAIL(auto_service.sync_insert_value_local(*autoinc_param))) {
        LOG_WARN("failed to sync last insert value", K(ret));
      }
    }

    uint64_t new_val = 0;
    if (OB_SUCC(ret)) {
      // check : to generate auto-increment value or not
      if (OB_FAIL(get_input_value(*expr.args_[1], ctx, input_value, *autoinc_param, is_to_generate, new_val))) {
        LOG_WARN("check generation failed", K(ret));
      } else if (is_to_generate && OB_FAIL(generate_autoinc_value(new_val, auto_service, autoinc_param, plan_ctx))) {
        LOG_WARN("generate autoinc value failed", K(ret));
      }
    }

    if (OB_SUCC(ret)) {
      if (!is_to_generate) {
        expr_datum.set_datum(*input_value);  // keep the input datum
      } else {
        ObObjTypeClass tc = ob_obj_type_class(expr.datum_meta_.type_);
        switch (tc) {
          case ObIntTC:
          case ObUIntTC: {
            expr_datum.set_uint(new_val);
            break;
          }
          case ObFloatTC: {
            expr_datum.set_float(static_cast<float>(new_val));
            break;
          }
          case ObDoubleTC: {
            expr_datum.set_double(static_cast<double>(new_val));
            break;
          }
          default: {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("only int/float/double types support auto increment", K(ret), K(expr.datum_meta_));
          }
        }
      }
    }

    if (OB_SUCC(ret)) {
      if (autoinc_param->autoinc_desired_count_ > 0) {
        --autoinc_param->autoinc_desired_count_;
      }

      if (OB_HIDDEN_PK_INCREMENT_COLUMN_ID != autoinc_param->autoinc_col_id_) {
        if (is_to_generate) {
          plan_ctx->set_autoinc_col_value(new_val);
        }
      }
    }
  }
  return ret;
}

}  // end namespace sql
}  // end namespace oceanbase