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

#ifndef OCEANBASE_SQL_ENGINE_EXPR_SQL_EXPRESSION_H_
#define OCEANBASE_SQL_ENGINE_EXPR_SQL_EXPRESSION_H_

#include "common/object/ob_object.h"
#include "common/row/ob_row.h"
#include "share/ob_i_sql_expression.h"

#include "sql/engine/expr/ob_postfix_expression.h"
#include "sql/engine/expr/ob_infix_expression.h"
#include "sql/engine/expr/ob_sql_expression_factory.h"
#include "sql/engine/sort/ob_base_sort.h"
#include "sql/engine/ob_operator.h"         // ObOpSchemaObj
class ObAggregateFunctionTest;

// 这个宏由于expr的构造需要传参，暂时没统一
#define OB_UNIS_DECODE_EXPR_DLIST(Type, expr_list, phy_plan) \
  do { \
    int64_t list_count = 0; \
    OB_UNIS_DECODE(list_count); \
    if (OB_UNLIKELY(list_count < 0)) { \
    } else { \
      for (int64_t i = 0; OB_SUCC(ret) && i < list_count; ++i) { \
        Type *p = NULL; \
        if (OB_FAIL(ObSqlExpressionUtil::make_sql_expr((phy_plan), p))) { \
          LOG_WARN("make sql expr failed", K(i), K(list_count), K(ret)); \
        } else if (OB_ISNULL(p)) { \
          ret = OB_BAD_NULL_ERROR; \
          LOG_WARN("sql expr is null", K(i), K(list_count), K(ret)); \
        } else if (OB_FAIL(p->deserialize(buf, data_len, pos))) { \
          LOG_WARN("deserialize expr failed", K(i), K(list_count), K(ret)); \
        } else { \
          if (!(expr_list).add_last(p)) { \
            ret = OB_ERR_UNEXPECTED; \
            LOG_WARN("add expr list failed", K(i), K(list_count), K(ret)); \
          } \
        } \
      } \
    } \
  } while(0)

namespace oceanbase
{
namespace sql
{
class ObPhysicalPlan;

class ObSqlExpression: public common::ObISqlExpression, public common::ObDLinkBase<ObSqlExpression>
{
  OB_UNIS_VERSION_V(1);
public:
  enum ExpressionType
  {
    EXPR_TYPE_SQL = 0,
    EXPR_TYPE_COLUMN,
    EXPR_TYPE_AGGREGATE,
    EXPR_TYPE_MAX
  };
public:
  ObSqlExpression(common::ObIAllocator &alloc, int64_t item_count = 0);
  virtual ~ObSqlExpression();

  int assign(const ObSqlExpression &other);

  int set_item_count(int64_t count);
  inline void set_need_construct_binding_array(bool need_construct) { need_construct_binding_array_ = need_construct; }
  inline bool need_construct_binding_array() const { return need_construct_binding_array_; }
  inline int64_t get_array_param_index() const { return array_param_index_; }
  /**
    common::ObIAllocator &alloc, * 设置表达式
   * @param expr [in] 表达式，表达方式与实现相关，目前定义为后缀表达式
   *
   * @return error code
   */
  virtual int add_expr_item(const ObPostExprItem &item, const ObRawExpr *raw_expr = nullptr);
  inline const ObSqlFixedArray<ObInfixExprItem> &get_expr_items() const
  {
    return infix_expr_.get_exprs();
  }
  virtual void reset();

  virtual void start_gen_infix_exr() { gen_infix_expr_ = true; }
  bool is_gen_infix_expr() const { return gen_infix_expr_; }
  void set_gen_infix_expr(const bool is_gen_infix_expr ) { gen_infix_expr_ = is_gen_infix_expr; }

  ObInfixExpression &get_infix_expr() { return infix_expr_; }

  bool is_equijoin_cond(int64_t &c1, int64_t &c2,
      common::ObObjType &cmp_type, common::ObCollationType &cmp_cs_type,
      bool &is_null_safe) const;
  /**
   * 根据表达式语义对row的值进行计算
   *
   * @param row [in] 输入行
   * @param result [out] 计算结果
   *
   * @return error code
   */
  virtual int calc(common::ObExprCtx &expr_ctx, const common::ObNewRow &row,
                   common::ObObj &result) const;
  virtual int calc(common::ObExprCtx &expr_ctx, const common::ObNewRow &row1,
                   const common::ObNewRow &row2,
                   common::ObObj &result) const;
  TO_STRING_KV(K_(infix_expr), K_(post_expr), K_(gen_infix_expr), KP(expr_));

  // check expression type
  int generate_idx_for_regexp_ops(int16_t &cur_regexp_op_count);
  inline bool is_empty() const;
  virtual int32_t get_type() const { return ObSqlExpression::EXPR_TYPE_SQL; }

  inline void set_fast_expr(ObFastExprOperator *fast_expr) { fast_expr_ = fast_expr; }

  bool is_use_jitted_expr() const
  {
    return false;
  }

  void set_is_pl_mock_default_expr(bool v) { is_pl_mock_default_expr_ = v; }
  bool get_is_pl_mock_default_expr() const { return is_pl_mock_default_expr_; }

  void set_expr(const ObExpr *expr) { expr_ = expr; }

  virtual const ObExpr *get_expr() const override { return expr_; }
private:
  DISALLOW_COPY_AND_ASSIGN(ObSqlExpression);
protected:
  friend class ::ObAggregateFunctionTest;
  common::ObIAllocator &inner_alloc_;
  // data members
  ObPostfixExpression post_expr_;
  //fast expr目前不序列化，不在远端执行
  ObFastExprOperator *fast_expr_;
  ObInfixExpression infix_expr_;
  int32_t array_param_index_;
  bool need_construct_binding_array_;
   // used for infix generation, no need to serialize
  bool gen_infix_expr_;

  // expression for static engine, only used in PL
  bool is_pl_mock_default_expr_;
  const ObExpr *expr_;
};

inline void ObSqlExpression::reset(void)
{
  common::ObDLinkBase<ObSqlExpression>::reset();
  post_expr_.reset();
  fast_expr_ = NULL;
  gen_infix_expr_ = false;
  infix_expr_.reset();
  need_construct_binding_array_ = false;
  array_param_index_ = common::OB_INVALID_INDEX;
}

inline bool ObSqlExpression::is_empty() const
{
  return infix_expr_.is_empty() && post_expr_.is_empty();
}

class ObColumnExpression: public ObSqlExpression, public common::ObIColumnExpression
{
  OB_UNIS_VERSION_V(1);
public:
  ObColumnExpression(common::ObIAllocator &alloc, int64_t item_count = 0);
  virtual ~ObColumnExpression();

  int assign(const ObColumnExpression &other);
  void set_result_index(int64_t index) { result_index_ = index; }
  inline int64_t get_result_index() const { return result_index_; }

  inline void set_collation_type(common::ObCollationType cs_type) { cs_type_ = cs_type; }
  inline common::ObCollationType get_collation_type() const { return cs_type_; }
  inline void set_accuracy(const common::ObAccuracy &accuracy) { accuracy_.set_accuracy(accuracy); }
  inline const common::ObAccuracy &get_accuracy() const { return accuracy_; }
  int calc_and_project(common::ObExprCtx &expr_ctx, common::ObNewRow &row) const;
  virtual void reset();
  virtual int32_t get_type() const { return ObSqlExpression::EXPR_TYPE_COLUMN; }
  int64_t to_string(char *buf, const int64_t buf_len) const;
private:
  DISALLOW_COPY_AND_ASSIGN(ObColumnExpression);
protected:
  int64_t result_index_; //result's index in output row
  common::ObCollationType cs_type_;
  common::ObAccuracy accuracy_;
};

inline void ObColumnExpression::reset()
{
  ObSqlExpression::reset();
  cs_type_ = common::CS_TYPE_INVALID;
}

class ObAggregateExpression: public ObColumnExpression
{
  OB_UNIS_VERSION_V(1);
public:
  ObAggregateExpression(common::ObIAllocator &alloc, int64_t item_count = 0);
  virtual ~ObAggregateExpression();

  int assign(const ObAggregateExpression &other);

  virtual void reset();
  virtual int32_t get_type() const { return ObSqlExpression::EXPR_TYPE_AGGREGATE; }
  virtual int calc(common::ObExprCtx &expr_ctx, const common::ObNewRow &row,
                   common::ObObj &result) const;
  virtual int calc(common::ObExprCtx &expr_ctx,
                   const common::ObNewRow &row1,
                   const common::ObNewRow &row2,
                   common::ObObj &result) const;
  int calc_result_row(common::ObExprCtx &expr_ctx,
                      const common::ObNewRow &row,
                      common::ObNewRow &result_row) const;

  int64_t to_string(char *buf, const int64_t buf_len) const;

  inline void set_aggr_func(ObItemType aggr_fun, bool is_distinct);
  inline int get_aggr_column(ObItemType &aggr_fun, bool &is_distinct,
                             common::ObCollationType &cs_type) const;
  inline int add_separator_param_expr_item(const ObPostExprItem &item, const ObRawExpr *raw_expr)
           { return separator_param_expr_.add_expr_item(item, raw_expr); }
  inline const ObSqlExpression &get_separator_param_expr() const { return separator_param_expr_; }
  // 不包括sort column的真正param的列数
  inline void set_real_param_col_count(int64_t real_param_col_count) { real_param_col_count_ = real_param_col_count; }
  inline int64_t get_real_param_col_count() const { return real_param_col_count_; }
  // 包括sort column的所有param的列数
  inline void set_all_param_col_count(int64_t all_param_col_count) { output_column_count_ = all_param_col_count; }
  inline int64_t get_all_param_col_count() const { return output_column_count_; }

  int init_sort_column_count(int64_t count) { return sort_columns_.init(count); }
  int init_sort_extra_infos_(int64_t count) { return extra_infos_.init(count); }
  int add_sort_column(const int64_t index,
                      common::ObCollationType cs_type,
                      bool is_ascending);
  inline const common::ObIArray<ObSortColumn> &get_sort_columns() const { return sort_columns_; }
  inline const common::ObIArray<ObOpSchemaObj> &get_sort_extra_infos() const { return extra_infos_; }
  inline common::ObIArray<ObOpSchemaObj> &get_sort_extra_infos() { return extra_infos_; }
  inline ObItemType get_aggr_func() const { return aggr_func_; }

  int init_aggr_cs_type_count(int64_t count) { return aggr_cs_types_.init(count); }
  int add_aggr_cs_type(common::ObCollationType cs_type) { return aggr_cs_types_.push_back(cs_type); }
  const common::ObIArray<common::ObCollationType> *get_aggr_cs_types() const { return &aggr_cs_types_; }
  virtual void start_gen_infix_exr() {
    gen_infix_expr_ = true;
    separator_param_expr_.start_gen_infix_exr();
    window_size_param_expr_.start_gen_infix_exr();
    item_size_param_expr_.start_gen_infix_exr();
    bucket_num_expr_.start_gen_infix_exr();
  }
  inline int add_window_size_param_expr_item(const ObPostExprItem &item,
                                             const ObRawExpr *raw_expr) {
    return window_size_param_expr_.add_expr_item(item, raw_expr); }
  inline const ObSqlExpression &get_window_size_param_expr() const {
    return window_size_param_expr_; }
  inline int add_item_size_param_expr_item(const ObPostExprItem &item, const ObRawExpr *raw_expr) {
    return item_size_param_expr_.add_expr_item(item, raw_expr); }
  inline const ObSqlExpression &get_item_size_param_expr() const {
    return item_size_param_expr_; }
  void set_is_need_deserialize_row(bool is_need) {
    is_need_deserialize_row_ = is_need;
  }
  bool is_need_deserialize_row() const {
    return is_need_deserialize_row_;
  }

  void set_pl_agg_udf_type_id(int64_t type_id) { pl_agg_udf_type_id_ = type_id; }
  int64_t get_pl_agg_udf_type_id() const { return pl_agg_udf_type_id_; }

  inline void set_result_type(ObExprResType result_type) { result_type_ = result_type; }
  inline ObExprResType get_result_type() const { return result_type_; }

  int init_pl_agg_udf_params_type_count(int64_t count) {
    return pl_agg_udf_params_type_.init(count); }
  int add_pl_agg_udf_param_type(ObExprResType type) {
    return pl_agg_udf_params_type_.push_back(type); }
  const common::ObIArray<ObExprResType> &get_pl_agg_udf_params_type() const {
    return pl_agg_udf_params_type_; }
  inline int add_bucket_num_expr_item(const ObPostExprItem &item, const ObRawExpr *raw_expr) {
    return bucket_num_expr_.add_expr_item(item, raw_expr); }
  inline const ObSqlExpression &get_bucket_num_expr() const {
    return bucket_num_expr_; }

private:
  DISALLOW_COPY_AND_ASSIGN(ObAggregateExpression);
protected:
  ObItemType aggr_func_;
  bool is_distinct_;
  common::ObFixedArray<ObSortColumn, common::ObIAllocator> sort_columns_;
  ObSqlExpression separator_param_expr_;
  int64_t real_param_col_count_;
public:
  common::ObFixedArray<common::ObCollationType, common::ObIAllocator> aggr_cs_types_;
protected:
  int64_t output_column_count_;
  common::ObFixedArray<ObOpSchemaObj, common::ObIAllocator> extra_infos_;//支持NULLs FIRST
protected:
  ObSqlExpression window_size_param_expr_;
  ObSqlExpression item_size_param_expr_;
  bool is_need_deserialize_row_;
protected:
  int64_t pl_agg_udf_type_id_;
  common::ObFixedArray<ObExprResType, common::ObIAllocator> pl_agg_udf_params_type_;
  ObExprResType result_type_;
  ObSqlExpression bucket_num_expr_;
};

inline void ObAggregateExpression::reset()
{
  ObColumnExpression::reset();
  aggr_func_ = ::T_INVALID;
  is_distinct_ = false;
  sort_columns_.reset();
  //separator_param_idx_ = common::OB_INVALID_INDEX;
  separator_param_expr_.reset();
  real_param_col_count_ = 0;
  aggr_cs_types_.reset();
  window_size_param_expr_.reset();
  item_size_param_expr_.reset();
  is_need_deserialize_row_ = false;
  pl_agg_udf_type_id_ = common::OB_INVALID_ID;
  pl_agg_udf_params_type_.reset();
  result_type_.reset();
  bucket_num_expr_.reset();
}

inline void ObAggregateExpression::set_aggr_func(ObItemType aggr_func, bool is_distinct)
{
  aggr_func_ = aggr_func;
  is_distinct_ = is_distinct;
}

inline int ObAggregateExpression::get_aggr_column(ObItemType &aggr_fun,
                                                  bool &is_distinct,
                                                  common::ObCollationType &cs_type) const
{
  int ret = common::OB_SUCCESS;
  aggr_fun = aggr_func_;
  is_distinct = is_distinct_;
  cs_type = cs_type_;
  return ret;
}

// ObExprOperatorFetcher is used fetch the ObExprOperator of ObExprGeneratorImpl.
// only override the add_expr_item.
struct ObExprOperatorFetcher: public ObSqlExpression
{
public:
  ObExprOperatorFetcher()
      //  the allocator is never used
      : ObSqlExpression(*lib::ObMallocAllocator::get_instance(), 0), op_(NULL)
  {}

  virtual int add_expr_item(const ObPostExprItem &item, const ObRawExpr *raw_expr) override
   {
    UNUSED(raw_expr);
    int ret = common::OB_SUCCESS;
    if (IS_EXPR_OP(item.get_item_type())) {
      if (NULL != op_) {
        ret = common::OB_ERR_UNEXPECTED;
        SQL_ENG_LOG(WARN, "only one expr operator expected", K(ret));
      } else {
        op_ = item.get_expr_operator();
      }
    } else {
      op_ = NULL;
    }
    return ret;
  }

  void reset() { op_ = NULL; }

  const ObExprOperator *op_;
};

class ObSqlExpressionUtil
{
public:
  static int make_sql_expr(ObPhysicalPlan *physical_plan, ObSqlExpression  *&expr);
  static int make_sql_expr(ObPhysicalPlan *physical_plan, ObColumnExpression  *&expr);
  static int make_sql_expr(ObPhysicalPlan *physical_plan, ObAggregateExpression  *&expr);
  static int add_expr_to_list(common::ObDList<ObSqlExpression> &list, ObSqlExpression *expr);
  static int copy_sql_expression(ObSqlExpressionFactory &sql_expression_factory,
                                 const ObSqlExpression *src_expr,
                                 ObSqlExpression *&dst_expr);
  static int copy_sql_expressions(ObSqlExpressionFactory &sql_expression_factory,
                                  const common::ObIArray<ObSqlExpression *> &src_exprs,
                                  common::ObIArray<ObSqlExpression *> &dst_exprs);
  static int expand_array_params(common::ObExprCtx &expr_ctx,
                                 const common::ObObj &src_param,
                                 const common::ObObj *&result);
private:
  DISALLOW_COPY_AND_ASSIGN(ObSqlExpressionUtil);
  ObSqlExpressionUtil();
  ~ObSqlExpressionUtil();
  template <class T>
  static int make_expr(ObPhysicalPlan *physical_plan, T *&expr);
};

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

#endif /* OCEANBASE_SQL_ENGINE_EXPR_SQL_EXPRESSION_H_ */