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

#include "sql/plan_cache/ob_plan_cache_util.h"
#include "sql/plan_cache/ob_plan_set.h"
#include "sql/session/ob_sql_session_info.h"
#include "share/schema/ob_schema_getter_guard.h"
#include "share/ob_i_tablet_scan.h"
#include "sql/engine/ob_exec_context.h"
#include "sql/executor/ob_task_executor.h"
#include "sql/ob_phy_table_location.h"
#include "sql/optimizer/ob_phy_table_location_info.h"
#include "sql/optimizer/ob_log_plan.h"
using namespace oceanbase::share;
using namespace oceanbase::share::schema;
using namespace oceanbase::omt;

namespace oceanbase
{
namespace sql
{
int ObGetAllPlanIdOp::set_key_array(common::ObIArray<uint64_t> *key_array)
{
int ret = common::OB_SUCCESS;
if (NULL == key_array) {
  ret = common::OB_INVALID_ARGUMENT;
  SQL_PC_LOG(WARN, "invalid argument", K(ret));
} else {
  key_array_ = key_array;
}
return ret;
}

int ObGetAllPlanIdOp::operator()(common::hash::HashMapPair<ObCacheObjID, ObILibCacheObject *> &entry)
{
  int ret = common::OB_SUCCESS;
  if (NULL == key_array_) {
    ret = common::OB_NOT_INIT;
    SQL_PC_LOG(WARN, "invalid argument", K(ret));
  } else if (ObLibCacheNameSpace::NS_CRSR == entry.second->get_ns() &&
      OB_FAIL(key_array_->push_back(entry.first))) {
    SQL_PC_LOG(WARN, "fail to push back plan_id", K(ret));
  }
  return ret;
}

int ObGetAllCacheIdOp::set_key_array(common::ObIArray<uint64_t> *key_array)
{
int ret = common::OB_SUCCESS;
if (NULL == key_array) {
  ret = common::OB_INVALID_ARGUMENT;
  SQL_PC_LOG(WARN, "invalid argument", K(ret));
} else {
  key_array_ = key_array;
}
return ret;
}

int ObGetAllCacheIdOp::operator()(common::hash::HashMapPair<ObCacheObjID, ObILibCacheObject *> &entry)
{
  int ret = common::OB_SUCCESS;
  if (NULL == key_array_ || OB_ISNULL(entry.second)) {
    ret = common::OB_NOT_INIT;
    SQL_PC_LOG(WARN, "invalid argument", K(ret));
  } else if (entry.second->get_ns() >= ObLibCacheNameSpace::NS_CRSR
            && entry.second->get_ns() <= ObLibCacheNameSpace::NS_PKG) {
    if (OB_ISNULL(entry.second)) {
      // do nothing
    } else if (!entry.second->added_lc()) {
      // do nothing
    } else if (OB_FAIL(key_array_->push_back(entry.first))) {
      SQL_PC_LOG(WARN, "fail to push back plan_id", K(ret));
    }
  }
  return ret;
}

int ObPlanCacheCtx::is_retry(bool &v) const
{
  int ret = OB_SUCCESS;
  v = 0;
  if (OB_ISNULL(sql_ctx_.session_info_)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid argument", K(ret));
  } else {
    v = sql_ctx_.session_info_->get_is_in_retry();
  }

  return ret;
}

int ObPlanCacheCtx::is_retry_for_dup_tbl(bool &v) const
{
  int ret = OB_SUCCESS;
  v = 0;
  if (OB_ISNULL(sql_ctx_.session_info_)) {
    ret = OB_INVALID_ARGUMENT;
    LOG_WARN("invalid argument", K(ret));
  } else {
    v = sql_ctx_.session_info_->get_is_in_retry_for_dup_tbl();
  }

  return ret;
}

int ObPhyLocationGetter::get_phy_locations(const common::ObIArray<ObTablePartitionInfo *> &partition_infos,
                                           ObIArray<ObCandiTableLoc> &candi_table_locs)
{
  int ret = OB_SUCCESS;
  //ObDASTableLoc table_loc;
  int64_t N = partition_infos.count();
  if (OB_FAIL(candi_table_locs.reserve(N))) {
    LOG_WARN("fail reserve memory", K(ret), K(N));
  }
  for (int64_t i = 0; OB_SUCC(ret) && i < N; i++) {
    if (OB_ISNULL(partition_infos.at(i))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("invalid partition info", K(ret));
    } else if (OB_FAIL(candi_table_locs.push_back(
                   partition_infos.at(i)->get_phy_tbl_location_info()))) {
      LOG_WARN("failed to push_back phy_location_info", K(ret),
               K(partition_infos.at(i)->get_phy_tbl_location_info()));
    } else { /* do nothing */ }
  }
  return ret;
}

//包含复制表的情况下, 选择完副本后调整复制表的副本选择使和非复制表的location一致(前提是非复制表都在同一server)
//好处是可以使得计划类型从 DIST --> REMOTE; 不能在ObSqlPlanSet::calc_phy_plan_type_by_proj计算
//的原因是get_phy_locations就会将物理位置赋值给task_exec_ctx; (实现参考了is_partition_in_same_server_by_proj)
int ObPhyLocationGetter::reselect_duplicate_table_best_replica(const ObIArray<ObCandiTableLoc> &phy_locations,
                                                               bool &on_same_server)
{
  int ret = OB_SUCCESS;
  bool has_duplicate_tbl = false;
  bool is_same = true;
  ObAddr normal_table_addr;
  ObAddr duplicate_table_addr;
  ObSEArray<ObAddr, 4> candi_addrs;
  ObSEArray<int64_t, 8> new_replic_idxs;
  int64_t proj_cnt = phy_locations.count();
  ObLSReplicaLocation replica_location;
  for (int64_t i = 0; OB_SUCC(ret) && is_same && i < proj_cnt; ++i) {
    const ObCandiTableLoc &ptli = phy_locations.at(i);
    if (ptli.get_partition_cnt() > 1) {
      is_same = false;
    } else if (ptli.get_partition_cnt() > 0) {
      const ObCandiTabletLoc &part_info = ptli.get_phy_part_loc_info_list().at(0);
      if (OB_FAIL(part_info.get_selected_replica(replica_location))) {
        SQL_PC_LOG(WARN, "fail to get selected replica", K(ret), K(ptli));
      } else if (!replica_location.is_valid()) {
        SQL_PC_LOG(WARN, "replica_location is invalid", K(ret), K(replica_location));
      } else if (!ptli.is_duplicate_table_not_in_dml()) {
        // handle normal table
        if (!normal_table_addr.is_valid()) {
          normal_table_addr = replica_location.get_server();
          SQL_PC_LOG(DEBUG, "part_location first replica", K(ret), K(replica_location));
        } else if (normal_table_addr != replica_location.get_server()) {
          is_same = false;
          SQL_PC_LOG(DEBUG, "part_location replica", K(ret), K(i), K(replica_location));
        }
      } else {
        // handle duplicate table
        if (!has_duplicate_tbl) {
          const ObIArray<ObRoutePolicy::CandidateReplica> &replicas =
              part_info.get_partition_location().get_replica_locations();
          for (int64_t j = 0; OB_SUCC(ret) && j < replicas.count(); ++j) {
            if (OB_FAIL(candi_addrs.push_back(replicas.at(j).get_server()))) {
              LOG_WARN("failed to push back servers", K(ret));
            }
          }
          duplicate_table_addr = replica_location.get_server();
          has_duplicate_tbl = true;
          SQL_PC_LOG(DEBUG, "has duplicate table");
        } else if (duplicate_table_addr != replica_location.get_server()) {
          duplicate_table_addr.reset();
        }
      }
    }
  }
  if (OB_SUCC(ret)) {
    if (!is_same) {
      // normal table does not use the same server, or
      // there is multi part table
      candi_addrs.reset();
      normal_table_addr.reset();
    } else if (!normal_table_addr.is_valid()) {
      // no normal table found
      if (duplicate_table_addr.is_valid()) {
        // duplicate tables use the same server
        candi_addrs.reset();
      }
    } else if (normal_table_addr == duplicate_table_addr) {
      // normal table and duplicate table already select the same server
      candi_addrs.reset();
    } else {
      // normal table uses the same server
      // duplicate table needs to reselect replica
      candi_addrs.reset();
      if (OB_FAIL(candi_addrs.push_back(normal_table_addr))) {
        LOG_WARN("failed to push back normal table addr", K(ret));
      }
    }
  }
  //如果无复制表或者非复制表就已经无法保证在同一server, 是分布式计划, 就没要必要在这里更改复制表的副本idx了
  if (OB_SUCC(ret) && !candi_addrs.empty()) {
    is_same = false;
    if (OB_FAIL(new_replic_idxs.prepare_allocate(proj_cnt))) {
      SQL_PC_LOG(WARN, "failed to pre-alloc array space", K(ret), K(proj_cnt));
    }
    for (int64_t i = 0; OB_SUCC(ret) && !is_same && i < candi_addrs.count(); ++i) {
      bool is_valid = true;
      const ObAddr &addr = candi_addrs.at(i);
      //a, 是否在同一server上有副本
      for (int64_t j = 0; OB_SUCC(ret) && is_valid && j < proj_cnt; ++j) {
        const ObCandiTableLoc &ptli = phy_locations.at(j);
        if (ptli.is_duplicate_table_not_in_dml()) {
          is_valid = ptli.get_phy_part_loc_info_list().at(0).is_server_in_replica(
                       addr, new_replic_idxs.at(j));
        }
      }
      //b, 所有复制表都有在 addr 上的副本, 一起更改之
      for (int64_t j = 0; OB_SUCC(ret) && is_valid && j < proj_cnt; ++j) {
        ObCandiTableLoc &ptli = const_cast<ObCandiTableLoc&>(phy_locations.at(j));
        if (!ptli.is_duplicate_table_not_in_dml()) {
          // do nothing
        } else if (OB_FAIL(ptli.get_phy_part_loc_info_list_for_update().at(0).
                           set_selected_replica_idx(new_replic_idxs.at(j)))) {
          SQL_PC_LOG(WARN, "failed to set selected replica idx", K(ret));
        }
      }
      if (OB_SUCC(ret) && is_valid) {
        is_same = true;
      }
    }
  }
  if (OB_SUCC(ret)) {
    on_same_server = is_same;
  }
  return ret;
}

//need_check_on_same_server: out, 是否需要检查分区在同一server, 如果这里检查过了就置为false
int ObPhyLocationGetter::get_phy_locations(const ObIArray<ObTableLocation> &table_locations,
                                           const ObPlanCacheCtx &pc_ctx,
                                           ObIArray<ObCandiTableLoc> &candi_table_locs,
                                           bool &need_check_on_same_server)
{
  int ret = OB_SUCCESS;
  bool has_duplicate_tbl_not_in_dml = false;
  ObExecContext &exec_ctx = pc_ctx.exec_ctx_;
  const ObDataTypeCastParams dtc_params = ObBasicSessionInfo::create_dtc_params(pc_ctx.sql_ctx_.session_info_);
  ObPhysicalPlanCtx *plan_ctx = exec_ctx.get_physical_plan_ctx();
  int64_t N = table_locations.count();
  bool is_retrying = false;
  bool on_same_server = true;
  need_check_on_same_server = true;
  if (OB_ISNULL(plan_ctx)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("invalid executor ctx!", K(ret), K(plan_ctx));
  } else {
    ObSEArray<const ObTableLocation *, 2> table_location_ptrs;
    ObSEArray<ObCandiTableLoc *, 2> phy_location_info_ptrs;
    const ParamStore &params = plan_ctx->get_param_store();
    if (OB_FAIL(candi_table_locs.prepare_allocate(N))) {
      LOG_WARN("phy_locations_info prepare allocate error", K(ret), K(N));
    } else {
      for (int64_t i = 0; OB_SUCC(ret) && i < N; i++) {
        const ObTableLocation &table_location = table_locations.at(i);
        ObCandiTableLoc &candi_table_loc = candi_table_locs.at(i);
        NG_TRACE(calc_partition_location_begin);
        // 这里认为materialized view的复制表是每个server都有副本的，
        // 因此这里不判断是否能生成materialized view了，一定都能生成
        if (OB_FAIL(table_location.calculate_candi_tablet_locations(exec_ctx,
                                                                    params,
                                                                    candi_table_loc.get_phy_part_loc_info_list_for_update(),
                                                                    dtc_params))) {
          LOG_WARN("failed to calculate partition location", K(ret));
        } else {
          NG_TRACE(calc_partition_location_end);
          if (table_location.is_duplicate_table_not_in_dml()) {
            has_duplicate_tbl_not_in_dml = true;
          }
          candi_table_loc.set_duplicate_type(table_location.get_duplicate_type());
          candi_table_loc.set_table_location_key(
              table_location.get_table_id(), table_location.get_ref_table_id());
          LOG_DEBUG("plan cache util", K(candi_table_loc));
        }
        if (OB_SUCC(ret)) {
          if (OB_FAIL(table_location_ptrs.push_back(&table_location))) {
            LOG_WARN("failed to push back table location ptrs", K(ret), K(i),
                     K(N), K(table_locations.at(i)));
          } else if (OB_FAIL(phy_location_info_ptrs.push_back(&candi_table_loc))) {
            LOG_WARN("failed to push back phy location info ptrs", K(ret), K(i),
                     K(N), K(candi_table_locs.at(i)));
          } else if (OB_FAIL(pc_ctx.is_retry_for_dup_tbl(is_retrying))) {
            LOG_WARN("failed to test if retrying", K(ret));
          } else if (is_retrying) {
            LOG_INFO("Physical Location from Location Cache", K(candi_table_loc));
          }
        }
      } // for end
    }

    //Only check the on_same_server when has table location in the phy_plan.
    if (OB_SUCC(ret) && N!=0 ) {
      if (OB_FAIL(ObLogPlan::select_replicas(exec_ctx, table_location_ptrs,
                                             exec_ctx.get_addr(),
                                             phy_location_info_ptrs))) {
        LOG_WARN("failed to select replicas", K(ret), K(table_locations),
                 K(exec_ctx.get_addr()), K(phy_location_info_ptrs));
      } else if (!has_duplicate_tbl_not_in_dml || is_retrying) {
        // do nothing
      } else if (OB_FAIL(reselect_duplicate_table_best_replica(candi_table_locs,
                                                               on_same_server))) {
        LOG_WARN("failed to reselect replicas", K(ret));
      } else if (!on_same_server) {
        need_check_on_same_server = false;
      }
      LOG_TRACE("after select_replicas", K(on_same_server), K(has_duplicate_tbl_not_in_dml),
                K(candi_table_locs), K(table_locations), K(ret));
    }
  }

  return ret;
}

int ObPhyLocationGetter::build_table_locs(ObDASCtx &das_ctx,
                                          const ObIArray<ObTableLocation> &table_locations,
                                          const ObIArray<ObCandiTableLoc> &candi_table_locs)
{
  int ret = OB_SUCCESS;
  CK(table_locations.count() == candi_table_locs.count());
  for (int64_t i = 0; OB_SUCC(ret) && i < table_locations.count(); i++) {
    if (OB_FAIL(das_ctx.add_candi_table_loc(table_locations.at(i).get_loc_meta(), candi_table_locs.at(i)))) {
      LOG_WARN("add candi table location failed", K(ret), K(table_locations.at(i).get_loc_meta()));
    }
  }
  if (OB_FAIL(ret)) {
    das_ctx.clear_all_location_info();
  }

  return ret;
}

//this function will rewrite the related tablet map info in DASCtx
int ObPhyLocationGetter::build_related_tablet_info(const ObTableLocation &table_location,
                                                   ObExecContext &exec_ctx,
                                                   DASRelatedTabletMap *&related_map)
{
  int ret = OB_SUCCESS;
  ObDataTypeCastParams dtc_params = ObBasicSessionInfo::create_dtc_params(exec_ctx.get_my_session());
  ObPhysicalPlanCtx *plan_ctx = exec_ctx.get_physical_plan_ctx();
  ObArray<ObObjectID> partition_ids;
  ObArray<ObObjectID> first_level_part_ids;
  ObArray<ObTabletID> tablet_ids;

  if (OB_FAIL(table_location.calculate_tablet_ids(exec_ctx,
                                                  plan_ctx->get_param_store(),
                                                  tablet_ids,
                                                  partition_ids,
                                                  first_level_part_ids,
                                                  dtc_params))) {
    LOG_WARN("calculate tablet ids failed", K(ret));
  } else {
    related_map = &exec_ctx.get_das_ctx().get_related_tablet_map();
    LOG_DEBUG("build_related tablet info", K(tablet_ids), K(partition_ids),
             K(table_location.get_loc_meta()), KPC(related_map));
  }
  return ret;
}

OB_SERIALIZE_MEMBER(ObTableRowCount, op_id_, row_count_);

int ObConfigInfoInPC::load_influence_plan_config()
{
  int ret = OB_SUCCESS;
  // Note: if you need to add a tenant config please
  //        uncomment next line to retrive tenant config.
  omt::ObTenantConfigGuard tenant_config(TENANT_CONF(tenant_id_));

  // For Cluster configs
  // here to add value of configs that can influence execution plan.
  enable_px_ordered_coord_ = GCONF._enable_px_ordered_coord;
  enable_newsort_ = GCONF._enable_newsort;
  is_strict_defensive_check_ = GCONF.enable_strict_defensive_check();
  is_enable_px_fast_reclaim_ = GCONF._enable_px_fast_reclaim;

  // For Tenant configs
  // tenant config use tenant_config to get configs
  if (tenant_config.is_valid()) {
    pushdown_storage_level_ = tenant_config->_pushdown_storage_level;
    rowsets_enabled_ = tenant_config->_rowsets_enabled;
    enable_px_batch_rescan_ = tenant_config->_enable_px_batch_rescan;
    bloom_filter_enabled_ = tenant_config->_bloom_filter_enabled;
    px_join_skew_handling_ = tenant_config->_px_join_skew_handling;
    px_join_skew_minfreq_ = static_cast<int8_t>(tenant_config->_px_join_skew_minfreq);
    min_cluster_version_ = GET_MIN_CLUSTER_VERSION();
  }

  return ret;
}

// reading values and generate strings
int ObConfigInfoInPC::serialize_configs(char *buf, int buf_len, int64_t &pos)
{
  int ret = OB_SUCCESS;
  pos = 0;

  // gen config str
  if (OB_FAIL(databuff_printf(buf, buf_len, pos,
                              "%d,", pushdown_storage_level_))) {
    SQL_PC_LOG(WARN, "failed to databuff_printf", K(ret), K(pushdown_storage_level_));
  } else if (OB_FAIL(databuff_printf(buf, buf_len, pos,
                              "%d,", rowsets_enabled_))) {
    SQL_PC_LOG(WARN, "failed to databuff_printf", K(ret), K(rowsets_enabled_));
  } else if (OB_FAIL(databuff_printf(buf, buf_len, pos,
                              "%d,", enable_px_batch_rescan_))) {
    SQL_PC_LOG(WARN, "failed to databuff_printf", K(ret), K(enable_px_batch_rescan_));
  } else if (OB_FAIL(databuff_printf(buf, buf_len, pos,
                              "%d,", enable_px_ordered_coord_))) {
    SQL_PC_LOG(WARN, "failed to databuff_printf", K(ret), K(enable_px_ordered_coord_));
  } else if (OB_FAIL(databuff_printf(buf, buf_len, pos,
                              "%d,", bloom_filter_enabled_))) {
    SQL_PC_LOG(WARN, "failed to databuff_printf", K(ret), K(bloom_filter_enabled_));
  } else if (OB_FAIL(databuff_printf(buf, buf_len, pos,
                              "%d,", enable_newsort_))) {
    SQL_PC_LOG(WARN, "failed to databuff_printf", K(ret), K(enable_newsort_));
  } else if (OB_FAIL(databuff_printf(buf, buf_len, pos,
                              "%d,", px_join_skew_handling_))) {
    SQL_PC_LOG(WARN, "failed to databuff_printf", K(ret), K(px_join_skew_handling_));
  } else if (OB_FAIL(databuff_printf(buf, buf_len, pos,
                              "%d,", is_strict_defensive_check_))) {
    SQL_PC_LOG(WARN, "failed to databuff_printf", K(ret), K(is_strict_defensive_check_));
  } else if (OB_FAIL(databuff_printf(buf, buf_len, pos,
                              "%d,", px_join_skew_minfreq_))) {
    SQL_PC_LOG(WARN, "failed to databuff_printf", K(ret), K(px_join_skew_minfreq_));

  } else if (OB_FAIL(databuff_printf(buf, buf_len, pos,
                               "%lu,", min_cluster_version_))) {
    SQL_PC_LOG(WARN, "failed to databuff_printf", K(ret), K(min_cluster_version_));
  } else if (OB_FAIL(databuff_printf(buf, buf_len, pos,
                               "%d", is_enable_px_fast_reclaim_))) {
    SQL_PC_LOG(WARN, "failed to databuff_printf", K(ret), K(is_enable_px_fast_reclaim_));
  } else {
    // do nothing
  }
  // trim last comma
  pos--;
  return ret;
}

}
}