/**
 * 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_POSTFIX_EXPRESSION_
#define OCEANBASE_SQL_ENGINE_EXPR_POSTFIX_EXPRESSION_

#include "lib/string/ob_string.h"
#include "lib/container/ob_array.h"
#include "lib/container/ob_fixed_array.h"
#include "share/ob_errno.h"
#include "common/ob_string_buf.h"
#include "common/object/ob_object.h"
#include "common/row/ob_row.h"
#include "share/ob_i_sql_expression.h"
#include "sql/parser/ob_item_type.h"
#include "sql/engine/expr/ob_expr_operator.h"
#include "sql/engine/ob_physical_plan_ctx.h"
#include "share/system_variable/ob_system_variable.h"
namespace oceanbase {
namespace common {
class ObRowkeyInfo;
}
namespace sql {
class ObResultSet;
class ObExprOperator;

template <typename T>
class ObSqlFixedArray {
public:
  ObSqlFixedArray() : data_(NULL), cap_(0), count_(0)
  {}
  int init(int64_t cap, common::ObIAllocator& allocator)
  {
    int ret = OB_SUCCESS;
    void* buf = NULL;
    if (cap < 0 || cap > INT32_MAX) {
      ret = OB_INVALID_ARGUMENT;
      SQL_ENG_LOG(WARN, "invalid argument", K(ret), K(cap));
    } else if (0 == cap) {
      // do nothing
    } else if (OB_ISNULL(buf = allocator.alloc(sizeof(T) * cap))) {
      ret = OB_ALLOCATE_MEMORY_FAILED;
      SQL_ENG_LOG(WARN, "failed to allocate memory", K(ret), K(cap), K(sizeof(T)));
    } else {
      data_ = static_cast<T*>(buf);
      for (int32_t i = 0; i < cap; i++) {
        new (data_ + i) T();
      }
      cap_ = static_cast<int32_t>(cap);
      count_ = 0;
    }
    return ret;
  }

  int push_back(const T& obj)
  {
    int ret = OB_SUCCESS;
    if (NULL == data_) {
      ret = OB_NOT_INIT;
      SQL_ENG_LOG(WARN, "array not init", K(ret), K(data_));
    } else if (count_ >= cap_) {
      ret = OB_SIZE_OVERFLOW;
      SQL_ENG_LOG(WARN, "sql fixed array size overflow", K(ret), K(cap_), K(count_));
    } else if (OB_FAIL(copy_assign(data_[count_], obj))) {
      SQL_ENG_LOG(WARN, "failed to copy assign data", K(ret));
    } else {
      count_++;
    }
    return ret;
  }
  inline T& at(const int64_t idx)
  {
    OB_ASSERT(idx >= 0 && idx < cap_);
    return data_[idx];
  }
  inline const T& at(const int64_t idx) const
  {
    OB_ASSERT(idx >= 0 && idx < cap_);
    return data_[idx];
  }
  inline T& operator[](const int64_t idx)
  {
    return at(idx);
  }
  inline const T& operator[](const int64_t idx) const
  {
    return at(idx);
  }
  inline bool empty() const
  {
    return 0 == count_;
  }
  inline int64_t count() const
  {
    return static_cast<int64_t>(count_);
  }

  int reserve(const int64_t cap, common::ObIAllocator& allocator)
  {
    int ret = OB_SUCCESS;
    if (cap < 0 || cap > INT32_MAX) {
      ret = OB_INVALID_ARGUMENT;
      SQL_ENG_LOG(WARN, "invalid argument", K(ret), K(cap));
    } else if (NULL == data_) {
      if (OB_FAIL(init(cap, allocator))) {
        SQL_ENG_LOG(WARN, "failed to init array", K(ret));
      }
    } else {
      if (cap > cap_) {
        ret = OB_SIZE_OVERFLOW;
        SQL_ENG_LOG(WARN, "failed to reserve capacity", K(ret), K(cap), K(cap_));
      }
    }
    return ret;
  }

  inline void reset(common::ObIAllocator& alloc)
  {
    destroy(alloc);
  }
  inline void reuse(common::ObIAllocator& alloc)
  {
    destroy(alloc);
  }
  inline void destroy(common::ObIAllocator& allocator)
  {
    if (NULL != data_) {
      for (int32_t i = 0; i < cap_; i++) {
        data_[i].~T();
      }
      allocator.free(data_);
      data_ = NULL;
    }
    cap_ = 0;
    count_ = 0;
  }

  int64_t to_string(char* buf, int64_t buf_len) const
  {
    int64_t pos = 0;
    J_ARRAY_START();
    int64_t N = count();
    for (int64_t i = 0; i < N - 1; i++) {
      BUF_PRINTO(at(i));
      J_COMMA();
    }
    if (N > 0) {
      BUF_PRINTO(at(N - 1));
    }
    J_ARRAY_END();
    return pos;
  }

  const T* get_ptr() const
  {
    return data_;
  }

private:
  T* data_;
  int32_t cap_;
  int32_t count_;
};

class ObPostExprItem {
public:
  ObPostExprItem() : v2_(), accuracy_(), item_type_(::T_INVALID)
  {}
  // setters
  OB_INLINE void set_item_type(ObItemType item_type)
  {
    item_type_ = item_type;
  }
  OB_INLINE void set_accuracy(const common::ObAccuracy& accuracy)
  {
    accuracy_ = accuracy;
  }
  int assign(const common::ObObj& obj);
  int assign(ObExprOperator* op);
  int assign(ObItemType item_type);
  int set_column(int64_t index);
  // getters
  inline ObItemType get_item_type() const
  {
    return item_type_;
  }
  inline const common::ObObj& get_obj() const
  {
    return *reinterpret_cast<const common::ObObj*>(&(v2_.v1_));
  }
  OB_INLINE bool can_get_value_directly() const;
  OB_INLINE int get_item_value_directly(
      const ObPhysicalPlanCtx& plan_ctx, const common::ObNewRow& row, const common::ObObj*& value) const;
  OB_INLINE int get_indirect_const(const ObPhysicalPlanCtx& phy_plan_ctx, const common::ObObj*& obj) const;
  OB_INLINE int64_t get_column() const
  {
    return v2_.cell_index_;
  }
  inline ObExprOperator* get_expr_operator()
  {
    return v2_.op_;
  }
  inline const ObExprOperator* get_expr_operator() const
  {
    return v2_.op_;
  }
  const common::ObAccuracy& get_accuracy() const
  {
    return accuracy_;
  }

  int64_t to_string(char* buf, const int64_t buf_len) const;
  int serialize(char* buf, const int64_t buf_len, int64_t& pos) const;
  int deserialize(common::ObIAllocator& alloc, const char* buf, const int64_t data_len, int64_t& pos);
  int64_t get_serialize_size() const;
  // for testing
  void set_int(int64_t v)
  {
    common::ObObj obj;
    obj.set_int(v);
    assign(obj);
  }
  /* for unittest only */
  int set_op(common::ObIAllocator& alloc, const char* op_name, ObExprOperator*& op);
  ///* for unittest only */
  void set_op(common::ObIAllocator& alloc, const char* op_name, int32_t real_param_num);

  uint16_t get_param_idx() const
  {
    return 0;
  }
  uint16_t get_param_num() const
  {
    return 0;
  }

protected:
  // members in a union can only be simple data types, so an obj can only be
  // constructed through a buffer in union.
  union {
    char v1_[sizeof(common::ObObj)];  // buffer of obj
    int64_t query_id_;
    int64_t cell_index_;  // column reference, aka cell index in ObRow
    ObExprOperator* op_;  // expression operator
  } v2_;
  common::ObAccuracy accuracy_;  // for const, column, questionmark
  ObItemType item_type_;

private:
  // we need push ObPostExprItem object into ObIArray, so must allow copy and assign.
  // DISALLOW_COPY_AND_ASSIGN(ObPostExprItem);
};

OB_INLINE bool ObPostExprItem::can_get_value_directly() const
{
  return IS_DATATYPE_OR_QUESTIONMARK_OP(item_type_) || T_REF_COLUMN == item_type_;
}

OB_INLINE int ObPostExprItem::get_item_value_directly(
    const ObPhysicalPlanCtx& plan_ctx, const common::ObNewRow& row, const common::ObObj*& value) const
{
  int ret = common::OB_SUCCESS;
  switch (item_type_) {
    case T_REF_COLUMN: {
      // expression evaluation access row.cells with index directly, skip the projection.
      if (OB_UNLIKELY(get_column() >= row.count_) || OB_UNLIKELY(get_column() < 0) || OB_ISNULL(row.cells_)) {
        ret = common::OB_INVALID_ARGUMENT;
        SQL_ENG_LOG(WARN, "value index is invalid", K(ret), K(get_column()), K_(row.count), K_(row.cells));
      } else {
        value = &row.cells_[get_column()];
        if (OB_UNLIKELY(ObBitType == value->get_type())) {
          // use object scale to store bit length
          const_cast<common::ObObj*>(value)->set_scale(get_accuracy().get_precision());
        } else if (-1 != get_accuracy().get_scale()) {
          const_cast<common::ObObj*>(value)->set_scale(get_accuracy().get_scale());
        }
      }
      break;
    }
    case T_QUESTIONMARK: {
      if (OB_FAIL(get_indirect_const(plan_ctx, value))) {
        SQL_ENG_LOG(WARN, "get indirect const from value item failed", K(ret), K(*this));
      }
      break;
    }
    default: {
      if (IS_DATATYPE_OP(item_type_)) {
        value = &get_obj();
      } else {
        ret = common::OB_ERR_UNEXPECTED;
        SQL_ENG_LOG(WARN, "invalid item type", K(item_type_));
      }
      break;
    }
  }
  return ret;
}

OB_INLINE int ObPostExprItem::get_indirect_const(const ObPhysicalPlanCtx& plan_ctx, const common::ObObj*& val) const
{
  int ret = common::OB_SUCCESS;
  switch (item_type_) {
    case T_QUESTIONMARK: {
      int64_t param_idx = -1;
      const auto& param_store = plan_ctx.get_param_store();
      if (OB_FAIL(get_obj().get_unknown(param_idx))) {
        SQL_ENG_LOG(WARN, "fail to get unknown", K(ret), K(get_obj()));
      } else if (OB_UNLIKELY(param_idx < 0 || param_idx >= param_store.count())) {
        ret = common::OB_ARRAY_OUT_OF_RANGE;
        SQL_ENG_LOG(WARN, "wrong index of question mark position", K(param_idx), "param_count", param_store.count());
      } else {
        val = &param_store.at(param_idx);
      }
      break;
    }
    default: {
      ret = common::OB_ERR_UNEXPECTED;
      SQL_ENG_LOG(WARN, "invalid type", K(ret), K_(item_type));
      break;
    }
  }
  return ret;
}

enum ObWriteExprItemFlag { NEW_OP_WHEN_COPY, NO_NEW_OP_WHEN_COPY };

enum ObSqlParamNumFlag {
  TWO_OR_THREE = -3,
  OCCUR_AS_PAIR = -2,
  MORE_THAN_ZERO = -1,
};

struct ObPostfixExpressionCalcStack {
  // should be larger than MAX_SQL_EXPRESSION_SYMBOL_COUNT(=256)
  static const int64_t STACK_SIZE = 1024 * 8;
  common::ObObj stack_[STACK_SIZE];
};

class ObPostfixExpression {
public:
  ObPostfixExpression(common::ObIAllocator& alloc, int64_t item_count);
  ~ObPostfixExpression();
  int assign(const ObPostfixExpression& other);

  inline void set_output_column_count(int64_t output_column_count)
  {
    output_column_count_ = output_column_count;
  }
  inline int64_t get_output_column_count() const
  {
    return output_column_count_;
  }

  int set_item_count(int64_t count)
  {
    return post_exprs_.init(count, str_buf_);
  }
  // add expression object into array directly,
  // user assure objects of postfix expr sequence.
  // int add_expr_obj(const common::ObObj &obj);
  int add_expr_item(const ObPostExprItem& item);
  inline const ObSqlFixedArray<ObPostExprItem>& get_expr_items() const
  {
    return post_exprs_;
  }
  void reset();
  int calc(common::ObExprCtx& expr_ctx, const common::ObNewRow& row, common::ObObj& result_val) const;
  int calc(common::ObExprCtx& expr_ctx, const common::ObNewRow& row1, const common::ObNewRow& row2,
      common::ObObj& result_val) const;
  int uk_fast_project(common::ObExprCtx& expr_ctx, const common::ObNewRow& row, common::ObObj& result_val) const;
  int calc_result_row(common::ObExprCtx& expr_ctx, const common::ObNewRow& row, common::ObNewRow& result_row) const;
  int calc_result_row(common::ObExprCtx& expr_ctx, const common::ObNewRow& row1, const common::ObNewRow& row2,
      common::ObNewRow& result_row) const;
  int calc_ref_column(const common::ObNewRow& row, common::ObNewRow& result_row, const ObPostExprItem& item,
      common::ObObj* stack, int64_t& stack_top) const;
  int calc_ref_column(const common::ObNewRow& row1, const common::ObNewRow& row2, common::ObNewRow& result_row,
      const ObPostExprItem& item, common::ObObj* stack, int64_t& stack_top) const;
  int calc_question_mark(common::ObExprCtx& expr_ctx, common::ObNewRow& result_row, const ObPostExprItem& item,
      common::ObObj* stack, int64_t& stack_top) const;
  int calc_other_op(
      common::ObExprCtx& expr_ctx, const ObPostExprItem& item, common::ObObj* stack, int64_t& stack_top) const;
  int calc_agg_param_list(
      common::ObNewRow& result_row, const ObPostExprItem& item, common::ObObj* stack, int64_t stack_top) const;
  template <ObItemType item_type>
  int calc_row(common::ObExprCtx& expr_ctx, const common::ObNewRow& row, common::ObNewRow& result_row,
      const ObPostExprItem& item, common::ObObj* stack, int64_t stack_top) const;
  int generate_idx_for_regexp_ops(int16_t& cur_regexp_op_count);
  bool is_empty() const;
  bool is_equijoin_cond(int64_t& c1, int64_t& c2, common::ObObjType& cmp_type, common::ObCollationType& cmp_cs_type,
      bool& is_null_safe) const;
  int64_t to_string(char* buf, const int64_t buf_len) const;
  NEED_SERIALIZE_AND_DESERIALIZE;

private:
  // check if the expr is const or column index.
  int check_expr_type(const int64_t type_val, bool& is_type, const int64_t stack_len) const;

private:
  static const int64_t DEF_STRING_BUF_SIZE = 64 * 1024L;
  static const int64_t BASIC_SYMBOL_COUNT = 64;
  typedef ObSqlFixedArray<ObPostExprItem> PostfixExprArray;
  void data_clear();

private:
  PostfixExprArray post_exprs_;
  common::ObIAllocator& str_buf_;
  int64_t output_column_count_;

private:
  DISALLOW_COPY_AND_ASSIGN(ObPostfixExpression);
};  // class ObPostfixExpression

inline bool ObPostfixExpression::is_empty() const
{
  return (0 == post_exprs_.count());
}

}  // namespace sql
}  // namespace oceanbase

#endif  // OCEANBASE_SQL_ENGINE_EXPR_POSTFIX_EXPRESSION_H_