/**
 * 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_coll_pred.h"
#include "sql/engine/ob_physical_plan_ctx.h"
#include "sql/engine/ob_exec_context.h"
#include "lib/hash/ob_hashmap.h"
#include "pl/ob_pl_user_type.h"
#include "pl/ob_pl_allocator.h"
#include "lib/utility/utility.h"
#include "share/object/ob_obj_cast.h"

namespace oceanbase
{
using namespace common;
namespace sql
{
OB_SERIALIZE_MEMBER((ObExprCollPred, ObExprOperator),
                    ms_type_,
                    ms_modifier_);

typedef hash::ObHashMap<ObObj, int64_t, common::hash::NoPthreadDefendMode> LocalNTSHashMap;

ObExprCollPred::ObExprCollPred(ObIAllocator &alloc)
  : ObExprOperator(alloc, T_OP_COLL_PRED, N_COLL_PRED, 2, NOT_VALID_FOR_GENERATED_COL, NOT_ROW_DIMENSION),
    ms_type_(ObMultiSetType::MULTISET_TYPE_INVALID),
    ms_modifier_(ObMultiSetModifier::MULTISET_MODIFIER_INVALID)
{
}

ObExprCollPred::~ObExprCollPred()
{
}

void ObExprCollPred::reset()
{
  ms_type_ = ObMultiSetType::MULTISET_TYPE_INVALID;
  ms_modifier_ = ObMultiSetModifier::MULTISET_MODIFIER_INVALID;
  ObExprOperator::reset();
}

int ObExprCollPred::assign(const ObExprOperator &other)
{
  int ret = OB_SUCCESS;
  if (other.get_type() != T_OP_COLL_PRED) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("expr operator is mismatch", K(other.get_type()));
  } else if (OB_FAIL(ObExprOperator::assign(other))) {
    LOG_WARN("assign parent expr failed", K(ret));
  } else {
    const ObExprCollPred &other_expr = static_cast<const ObExprCollPred &>(other);
    ms_type_ = other_expr.ms_type_;
    ms_modifier_ = other_expr.ms_modifier_;
  }
  return ret;
}

int ObExprCollPred::calc_result_type2(ObExprResType &type,
                                    ObExprResType &type1,
                                    ObExprResType &type2,
                                    ObExprTypeCtx &type_ctx) const
{
  UNUSED(type_ctx);
  int ret = OB_SUCCESS;
  if (lib::is_oracle_mode()) {
    type.set_type(ObTinyIntType);
    type.set_precision(DEFAULT_PRECISION_FOR_BOOL);
    type.set_scale(DEFAULT_SCALE_FOR_INTEGER);
  } else {
    ret = OB_NOT_SUPPORTED;
    LOG_WARN("multiset operator not support non udt type", K(type1), K(type2), K(ret));
    LOG_USER_ERROR(OB_NOT_SUPPORTED, "multiset operator non udt type");
  }

  return ret;
}

#define FILL_HASH_MAP(map_name, coll, map_cnt) \
do { \
  if (OB_FAIL(map_name.create(coll->get_actual_count(), ObModIds::OB_SQL_HASH_SET))) { \
    LOG_WARN("fail create hash map", K(coll->get_actual_count()), K(ret)); \
  } else { \
    const ObObj *elem = NULL; \
    bool is_del = false; \
    ObObj *data_arr = static_cast<ObObj*>(coll->get_data()); \
    for (int64_t i = 0; OB_SUCC(ret) && i < coll->get_count(); ++i) {\
      if (OB_FAIL(coll->is_elem_deleted(i, is_del))) { \
        LOG_WARN("failed to check is collection elem deleted", K(ret)); \
      } else if (!is_del) { \
        elem = data_arr + i;\
        ret = map_name.set_refactored(*elem, i);\
        if (OB_HASH_EXIST == ret) {\
          ret = OB_SUCCESS;\
          continue;\
        } else if (OB_SUCC(ret)) {\
          map_cnt++;\
        } else {\
          LOG_WARN("insert elem into hashmap failed.", K(ret));\
        }\
      } \
    }\
  }\
} while(0)

int ObExprCollPred::compare_obj(const ObObj &obj1, const ObObj &obj2, ObCompareCtx &cmp_ctx) {
  UNUSED(cmp_ctx);
  return obj1 == obj2 ? 0 : 1;
}

int ObExprCollPred::calc_collection_is_contained_without_null(const pl::ObPLCollection *c1,
                                                     const pl::ObPLCollection *c2,
                                                     int64_t tz_offset,
                                                     const ObExprCalcType calc_type,
                                                     CollectionPredRes &result)
{
  int ret = OB_SUCCESS;
  obj_cmp_func lt_cmp_fp;
  const ObObjType type1 = c1->get_element_type().get_obj_type();
  const ObObjType type2 = c2->get_element_type().get_obj_type();
  ObObjTypeClass tc1 = ob_obj_type_class(type1);
  ObObjTypeClass tc2 = ob_obj_type_class(type2);
  if (OB_FAIL(ObObjCmpFuncs::get_cmp_func(tc1, tc2, CO_LT, lt_cmp_fp))) {
    LOG_WARN("get cmp func failed", K(type1), K(type2), K(tc1), K(tc2), K(ret));
  } else {
    ObCompareCtx cmp_ctx(calc_type.get_type(),
                       calc_type.get_collation_type(),
                       false,
                       tz_offset,
                       default_null_pos());
    struct udtComparer{
      udtComparer(ObCompareCtx &cmp_ctx, common::obj_cmp_func cmp_func) :
      cmp_ctx_(cmp_ctx),
      cmp_func_(cmp_func) {}

      bool operator()(const ObObj *&e1, const ObObj *&e2) {
        int cmpRes = cmp_func_(*e1, *e2, cmp_ctx_);
        return cmpRes;
      }
      ObCompareCtx &cmp_ctx_;
      common::obj_cmp_func cmp_func_;
    };
    udtComparer uc(cmp_ctx, lt_cmp_fp);
    common::ObArray<const ObObj *> c1_copy, c2_copy;
    bool del_flag = false;
    for (int64_t i = 0; OB_SUCC(ret) && i < c1->get_count(); ++i) {
      const ObObj *elem = reinterpret_cast<const ObObj*>(c1->get_data()) + i;
      CK (OB_NOT_NULL(elem));
      if (OB_SUCC(ret)) {
        if (elem->is_null()) {
        } else if (c1->is_elem_deleted(i, del_flag)) {
          LOG_WARN("failed to test if element is deleted", K(*elem), K(ret), K(i));
        } else {
          if (!del_flag) {
            OZ (c1_copy.push_back(elem));
          }
        }
      }
    }
    for (int64_t i = 0; OB_SUCC(ret) && i < c2->get_count(); ++i) {
      const ObObj *elem = reinterpret_cast<const ObObj*>(c2->get_data()) + i;
      CK (OB_NOT_NULL(elem));
      if (OB_SUCC(ret)) {
        if (elem->is_null()) {
        } else if (c2->is_elem_deleted(i, del_flag)) {
          LOG_WARN("failed to test if element is deleted", K(*elem), K(ret), K(i));
        } else {
          if (!del_flag) {
            OZ (c2_copy.push_back(elem));
          }
        }
      }
    }
    int64_t c1_cnt = c1_copy.count();
    int64_t c2_cnt = c2_copy.count();
    if (c1_cnt > 0 && c2_cnt > 0) {
      result = COLL_PRED_TRUE;
      if (c1_cnt > c2_cnt) {
        result = COLL_PRED_FALSE;
      } else {
        const ObObj **first = &c1_copy.at(0);
        std::sort(first, first + c1_cnt, uc);
        first = &c2_copy.at(0);
        std::sort(first, first + c2_cnt, uc);
        for (int64_t i = 0; OB_SUCC(ret) && i < c1_copy.count(); ++i) {
          if (0 != compare_obj(*(c1_copy.at(i)), *(c2_copy.at(i)), cmp_ctx)) {
            result = COLL_PRED_FALSE;
            break;
          }
        }
      }
    } else {
      if (0 == c1_cnt && 0 == c2_cnt) {
        result = COLL_PRED_BOTH_COLL_ZERO;
      } else if (0 == c1_cnt) {
        result = COLL_PRED_FIRST_COLL_ZERO;
      } else if (0 == c2_cnt) {
        result = COLL_PRED_SECOND_COLL_ZERO;
      }
    }
  }

  return ret;
}

int ObExprCollPred::calc_is_submultiset(const ObObj &obj1,
                                     const ObObj &obj2,
                                     int64_t tz_offset,
                                     const ObExprCalcType calc_type,
                                     CollectionPredRes &result)
{
  int ret = OB_SUCCESS;
  result = COLL_PRED_FALSE;
  if (obj1.get_meta().is_ext() && obj2.get_meta().is_ext()) {
    pl::ObPLCollection *c1 = reinterpret_cast<pl::ObPLCollection *>(obj1.get_ext());
    pl::ObPLCollection *c2 = reinterpret_cast<pl::ObPLCollection *>(obj2.get_ext());
    int64_t c1_cnt = c1->get_actual_count();
    int64_t c2_cnt = c2->get_actual_count();
    // 1) return true when:
    // 1. obj1 is not null and contains no row, return true whatever obj2 is.
    // for example obj nest_type := nest_type();
    // 2. obj1 and obj2 not null, obj1 does not contain any null element, obj1 elem one-to-one
    // mapping to obj2 element.

    // 2) return null when:
    // 1. obj1 is null
    // 2. obj2 is null, and obj1 is not null and not empty.
    // 3. obj1 contain null element, and any non null is element is one-to-one mapping to obj2 elem
    // for example:  nt1(1,2,3,4,5), nt2(1,2,NULL), nt3(1,7,null); nt2 submultiset of nt1 => null
    // nt3 submultiset nt1 => false

    // 3) return false when:
    // if none of above conditions occur, return false;
    if (OB_ISNULL(c1) || OB_ISNULL(c2)) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("union udt failed due to null udt", K(ret), K(obj1), K(obj2));
    } else if (pl::PL_NESTED_TABLE_TYPE != c1->get_type()
              || pl::PL_NESTED_TABLE_TYPE != c2->get_type()) {
      ret = OB_NOT_SUPPORTED;
      LOG_WARN("not support udt union except nested table", K(ret), K(c1), K(c2));
      LOG_USER_ERROR(OB_NOT_SUPPORTED, "udt union except nested table");
    } else if ((c1->get_element_type().get_obj_type() != c2->get_element_type().get_obj_type())) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("udt union failed due to uninited", K(ret));
    } else if (0 == c1_cnt && (c1->is_inited())) {
      result = COLL_PRED_TRUE;
    } else if (!c1->is_inited()) {
      result = COLL_PRED_NULL; // null
    } else if (!c2->is_inited()) {
      result = COLL_PRED_NULL;
    } else if (c1_cnt > c2_cnt) {
      result = COLL_PRED_FALSE;
    } else if (calc_collection_is_contained_without_null(c1, c2, tz_offset, calc_type, result)) {
      LOG_WARN("faile to calc multiset without null and delete val", K(ret));
    } else {
      // 去除了null和delete数据之后比较，如果是包含关系，但是c1含有null，置结果为null.
      if (COLL_PRED_TRUE == result && c1->is_contain_null_val()) {
        result = COLL_PRED_NULL;
      }
    }
  }
  return ret;
}

OB_DEF_SERIALIZE(ObExprCollPredInfo)
{
  int ret = OB_SUCCESS;
  LST_DO_CODE(OB_UNIS_ENCODE,
              ms_type_,
              ms_modifier_,
              tz_offset_,
              result_type_);
  return ret;
}

OB_DEF_DESERIALIZE(ObExprCollPredInfo)
{
  int ret = OB_SUCCESS;
  LST_DO_CODE(OB_UNIS_DECODE,
              ms_type_,
              ms_modifier_,
              tz_offset_,
              result_type_);
  return ret;
}

OB_DEF_SERIALIZE_SIZE(ObExprCollPredInfo)
{
  int64_t len = 0;
  LST_DO_CODE(OB_UNIS_ADD_LEN,
              ms_type_,
              ms_modifier_,
              tz_offset_,
              result_type_);
  return len;
}

int ObExprCollPredInfo::deep_copy(common::ObIAllocator &allocator,
                         const ObExprOperatorType type,
                         ObIExprExtraInfo *&copied_info) const
{
  int ret = common::OB_SUCCESS;
  OZ(ObExprExtraInfoFactory::alloc(allocator, type, copied_info));
  ObExprCollPredInfo &other = *static_cast<ObExprCollPredInfo *>(copied_info);
  other.ms_type_ = ms_type_;
  other.ms_modifier_ = ms_modifier_;
  other.tz_offset_ = tz_offset_;
  other.result_type_ = result_type_;
  return ret;
}

template <typename RE>
int ObExprCollPredInfo::from_raw_expr(RE &raw_expr)
{
  int ret = OB_SUCCESS;
  ObCollPredRawExpr &set_expr 
       = const_cast<ObCollPredRawExpr &> (static_cast<const ObCollPredRawExpr&>(raw_expr));
  ms_type_ = set_expr.get_multiset_type();
  ms_modifier_ = set_expr.get_multiset_modifier();
  return ret;
}

int ObExprCollPred::cg_expr(ObExprCGCtx &expr_cg_ctx,
                            const ObRawExpr &raw_expr,
                            ObExpr &rt_expr) const
{
  int ret = OB_SUCCESS;
  if (2 != rt_expr.arg_cnt_) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("wrong param num for coll pred", K(ret), K(rt_expr.arg_cnt_));
  } else if (OB_ISNULL(expr_cg_ctx.session_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("session info is nullptr", K(ret)); 
  } else {
    ObIAllocator &alloc = *expr_cg_ctx.allocator_;
    const ObCollPredRawExpr &fun_sys = static_cast<const ObCollPredRawExpr &>(raw_expr);
    ObExprCollPredInfo *info = OB_NEWx(ObExprCollPredInfo, (&alloc), alloc, T_OP_COLL_PRED);
    if (NULL == info) {
      ret = OB_ALLOCATE_MEMORY_FAILED;
      LOG_WARN("allocate memory failed", K(ret));
    } else {
      OZ(info->from_raw_expr(fun_sys));
      const ObTimeZoneInfo *tz_info = get_timezone_info(expr_cg_ctx.session_);
      int64_t tz_offset = 0;
      if (OB_FAIL(get_tz_offset(tz_info, tz_offset))) {
        LOG_WARN("failed to get tz offset", K(ret));
      } else {
        info->tz_offset_ = tz_offset;
        info->result_type_ = result_type_;
        rt_expr.extra_info_ = info;
        rt_expr.eval_func_ = eval_coll_pred;
      }
    }
  }
  return ret;
}

int ObExprCollPred::eval_coll_pred(const ObExpr &expr, ObEvalCtx &ctx, ObDatum &res)
{
  int ret = OB_SUCCESS;
  ObDatum *datum1 = nullptr;
  ObDatum *datum2 = nullptr;
  ObObj result;
  ObObj obj1;
  ObObj obj2;
  const ObExprCollPredInfo *info = static_cast<ObExprCollPredInfo *>(expr.extra_info_);
  if (OB_FAIL(expr.eval_param_value(ctx, datum1, datum2))) {
    LOG_WARN("failed to eval params", K(ret));
  } else if (lib::is_oracle_mode()) {
    if (OB_FAIL(datum1->to_obj(obj1, expr.args_[0]->obj_meta_))) {
      LOG_WARN("failed to convert to obj", K(ret));
    } else if (OB_FAIL(datum2->to_obj(obj2, expr.args_[1]->obj_meta_))) {
      LOG_WARN("failed to convert to obj", K(ret));
    } else {
      switch (info->ms_type_)
      {
      case MULTISET_TYPE_SUBMULTISET: {
        CollectionPredRes pred_res = COLL_PRED_INVALID;
        if (OB_FAIL(calc_is_submultiset(obj1, obj2, info->tz_offset_,
                                        info->result_type_.get_calc_meta(), pred_res))) {
          LOG_WARN("failed to call submultiset", K(ret));
        } else {
          if (COLL_PRED_NULL == pred_res) {
            result.set_null();
          } else {
            if (pred_res ^ (MULTISET_MODIFIER_NOT == info->ms_modifier_)) {
              result.set_tinyint(1);
            } else {
              result.set_tinyint(0);
            }
          }
        }
      }
        break;
      case MULTISET_TYPE_MEMBER_OF: {
        if (obj2.get_meta().is_ext()) {
          pl::ObPLCollection *c2 = reinterpret_cast<pl::ObPLCollection *>(obj2.get_ext());
          if (OB_NOT_NULL(c2) && 0 < c2->get_actual_count()) {
            ObObj *elem = static_cast<ObObj*>(c2->get_data());
            ObObj mem_cast;
            const ObObj * res_obj1 = &obj1;
            ObCollationType cast_coll_type = elem->get_collation_type();
            ObCastMode cp_cast_mode;
            if (OB_FAIL(ObSQLUtils::get_default_cast_mode(ctx.exec_ctx_.get_my_session(),
                                                          cp_cast_mode))) {
              LOG_WARN("failed to get default cast mode", K(ret));
            }
            const ObDataTypeCastParams dtc_params 
                   = ObBasicSessionInfo::create_dtc_params(ctx.exec_ctx_.get_my_session());
            ObCastCtx cast_ctx(&ctx.exec_ctx_.get_allocator(),
                               &dtc_params,
                               get_cur_time(ctx.exec_ctx_.get_physical_plan_ctx()),
                               cp_cast_mode,
                               cast_coll_type,
                               nullptr);
            if (OB_FAIL(ret)) {
            } else if (OB_FAIL(ObObjCaster::to_type(elem->get_type(), cast_ctx,
                                                    obj1, mem_cast, res_obj1))) {
              LOG_WARN("failed to cast member to collection elem type", K(ret));
            } else {
              LocalNTSHashMap dmap_c;
              int64_t res_cnt = 0;
              FILL_HASH_MAP(dmap_c, c2, res_cnt);
              if (OB_SUCC(ret)) {
                if (OB_NOT_NULL(dmap_c.get(*res_obj1)) ^ (MULTISET_MODIFIER_NOT == info->ms_modifier_)) {
                  result.set_tinyint(1);
                } else {
                  result.set_tinyint(0);
                }
              }
            }
          }
        }
      }
        break;
      case MULTISET_TYPE_IS_SET: {
        if (obj1.get_meta().is_ext()) {
          pl::ObPLCollection *c1 = reinterpret_cast<pl::ObPLCollection *>(obj1.get_ext());
          if (OB_NOT_NULL(c1)) {
            LocalNTSHashMap dmap_c;
            int64_t count = c1->get_actual_count();
            int res_cnt = 0;
            if (0 == count) {
              // empty nest table is a set
              result.set_tinyint(1);
            } else if (!c1->is_inited()) {
              result.set_null();
            } else {
              FILL_HASH_MAP(dmap_c, c1, res_cnt);
              if (OB_SUCC(ret)) {
                if ((count == res_cnt) ^ (MULTISET_MODIFIER_NOT == info->ms_modifier_)) {
                  result.set_tinyint(1);
                } else {
                  result.set_tinyint(0);
                }
              }
            }
          } else {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("get null collection structure", K(ret));
          }
        }
      }
        break;
      case MULTISET_TYPE_EMPTY: {
        if (obj1.get_meta().is_ext()) {
          pl::ObPLCollection *c1 = reinterpret_cast<pl::ObPLCollection *>(obj1.get_ext());
          int32_t pred_res = -1;
          if (OB_NOT_NULL(c1)) {
            if (c1->is_nested_table() || c1->is_varray()) {
              if (!c1->is_inited()) {
                result.set_null();
              } else if (0 < c1->get_actual_count()) {
                pred_res = 1;
              } else {
                pred_res = 0;
              }
            } else {
              ret = OB_NOT_SUPPORTED;
              LOG_WARN("not support other type except nest table and varray", K(ret));
              LOG_USER_ERROR(OB_NOT_SUPPORTED, "other type except nest table and varray");
            }
            if (OB_SUCC(ret) && -1 != pred_res) {
              if (pred_res ^ (MULTISET_MODIFIER_NOT == info->ms_modifier_)) {
                result.set_tinyint(0);
              } else {
                result.set_tinyint(1);
              }
            }
          } else {
            ret = OB_ERR_UNEXPECTED;
            LOG_WARN("get null collection struct", K(ret));
          }
        }
      }
        break;
      default:
        ret = OB_ERR_UNEXPECTED;
        LOG_WARN("unknown collection predicate condition", K(ret));
        break;
      }
      if (OB_SUCC(ret)) {
        OZ(res.from_obj(result, expr.obj_datum_map_));
        OZ(expr.deep_copy_datum(ctx, res));
      }
    }
  }
  return ret;
}

}  // namespace sql
}  // namespace oceanbase