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

#include "ob_anonymous_block_resolver.h"
#include "ob_anonymous_block_stmt.h"
#include "pl/ob_pl_stmt.h"
#include "pl/ob_pl_package.h"
#include "pl/ob_pl_compile.h"
#include "sql/resolver/ob_resolver_utils.h"

namespace oceanbase
{
namespace sql
{

int ObAnonymousBlockResolver::resolve(const ParseNode &parse_tree)
{
  int ret = OB_SUCCESS;
  ObAnonymousBlockStmt *stmt = NULL;
  ParseNode *block_node = NULL;
  void *params_buf = NULL;
  if (OB_ISNULL(session_info_)
      || OB_ISNULL(params_.param_list_)
      || OB_ISNULL(allocator_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("Argument is NULL",
             K(session_info_), K(params_.param_list_), K(allocator_), K(ret));
  } else if (OB_ISNULL(stmt = create_stmt<ObAnonymousBlockStmt>())
             || OB_ISNULL(params_buf = allocator_->alloc(sizeof(ParamStore)))) {
    ret = OB_ALLOCATE_MEMORY_FAILED;
    LOG_ERROR("create index stmt failed", K(ret));
  } else{
    ParamStore *param_store = new(params_buf)ParamStore( ObWrapperAllocator(*allocator_) );
    stmt->set_params(param_store);
    stmt_ = stmt;
  }
  CK (OB_NOT_NULL(stmt));
  if (OB_SUCC(ret)) {
    if (params_.is_prepare_protocol_) {
      stmt->set_prepare_protocol(true);
      stmt->set_stmt_id(params_.statement_id_);
      stmt->set_sql(params_.cur_sql_);
      if ((params_.is_prepare_stage_
            || params_.is_pre_execute_)
          && OB_ISNULL(session_info_->get_pl_context())) {
        CK (OB_LIKELY(T_SP_ANONYMOUS_BLOCK == parse_tree.type_));
        CK (OB_NOT_NULL(block_node = parse_tree.children_[0]));
        CK (OB_LIKELY(T_SP_BLOCK_CONTENT == block_node->type_
                      || T_SP_LABELED_BLOCK == block_node->type_));
        OZ (resolve_anonymous_block(*block_node, *stmt, true));
        if (OB_SUCC(ret) && params_.is_pre_execute_) {
          OZ (add_param());
        }
      } else {
        if (params_.is_prepare_stage_) {
          CK (OB_LIKELY(T_SP_ANONYMOUS_BLOCK == parse_tree.type_));
          CK (OB_NOT_NULL(block_node = parse_tree.children_[0]));
          CK (OB_LIKELY(T_SP_BLOCK_CONTENT == block_node->type_
                        || T_SP_LABELED_BLOCK == block_node->type_));
          OZ (resolve_anonymous_block(*block_node, *stmt, false));
        }
        OZ (add_param());
      }
    } else if (OB_UNLIKELY(T_SP_ANONYMOUS_BLOCK != parse_tree.type_
                           || OB_ISNULL(block_node = parse_tree.children_[0]))) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("the children of parse tree is NULL", K(ret));
    } else if (T_SP_BLOCK_CONTENT != block_node->type_
               && T_SP_LABELED_BLOCK != block_node->type_) {
      ret = OB_ERR_UNEXPECTED;
      LOG_WARN("Invalid procedure name node", K(block_node->type_), K(ret));
    } else {
      CK (OB_LIKELY(T_SP_ANONYMOUS_BLOCK == parse_tree.type_));
      CK (OB_NOT_NULL(block_node = parse_tree.children_[0]));
      CK (OB_LIKELY(T_SP_BLOCK_CONTENT == block_node->type_
                    || T_SP_LABELED_BLOCK == block_node->type_));
      OX (stmt->set_prepare_protocol(false));
      OX (stmt->set_body(block_node));
    }
  }
  return ret;
}

int ObAnonymousBlockResolver::resolve_anonymous_block(
  ParseNode &block_node, ObAnonymousBlockStmt &stmt, bool resolve_inout_param)
{
  int ret = OB_SUCCESS;
  HEAP_VAR(pl::ObPLFunctionAST, func_ast, *(params_.allocator_)) {
    ParamStore param_list( ObWrapperAllocator(*(params_.allocator_)) );
    const ParamStore *p_param_list = (params_.param_list_ != NULL && params_.param_list_->count() > 0)
        ? (params_.param_list_) : &param_list;
    pl::ObPLPackageGuard package_guard(params_.session_info_->get_effective_tenant_id());
    pl::ObPLResolver resolver(*(params_.allocator_),
                              *(params_.session_info_),
                              *(params_.schema_checker_->get_schema_guard()),
                              package_guard,
                              *(params_.sql_proxy_),
                              *(params_.expr_factory_),
                              NULL,
                              true,
                              false,
                              false,
                              p_param_list);
    for (int64_t i = 0; OB_SUCC(ret) && i < params_.query_ctx_->question_marks_count_; ++i) {
      OZ (param_list.push_back(ObObjParam(ObObj(ObNullType))));
    }
    OZ (package_guard.init());
    OX (func_ast.set_db_name(params_.session_info_->get_database_name()));
    OZ (pl::ObPLCompiler::init_anonymous_ast(
          func_ast,
          *(params_.allocator_),
          *(params_.session_info_),
          *(params_.sql_proxy_),
          *(params_.schema_checker_->get_schema_guard()),
          package_guard,
          p_param_list));
    OZ (resolver.init(func_ast));
    OZ (resolver.resolve_root(&block_node, func_ast));
    for (int64_t i = 0; OB_SUCC(ret) && i < func_ast.get_dependency_table().count(); ++i) {
      OZ (stmt.add_global_dependency_table(func_ast.get_dependency_table().at(i)));
    }
    
    const pl::ObPLSymbolTable &symbol_table = func_ast.get_symbol_table();
    for (int64_t i = 0;
        OB_SUCC(ret) && resolve_inout_param && i < func_ast.get_arg_count(); ++i) {
      const pl::ObPLVar *symbol = symbol_table.get_symbol(i);
      CK (OB_NOT_NULL(symbol));
      if (OB_FAIL(ret)) {
      } else if (!symbol->is_readonly()) {
        OZ (stmt.get_out_idx().add_member(i));
      }
    }
  }
  return ret;
}

int ObAnonymousBlockResolver::add_param()
{
  int ret = OB_SUCCESS;
  ObAnonymousBlockStmt *anonymous_stmt = NULL;
  if (OB_ISNULL(stmt_)
      || OB_ISNULL(params_.param_list_)) {
    ret = OB_ERR_UNEXPECTED;
    LOG_WARN("parameter is NULL", K(stmt_), K(params_.param_list_), K(ret));
  } else {
    anonymous_stmt = static_cast<ObAnonymousBlockStmt*>(stmt_);
  }
  CK (OB_NOT_NULL(anonymous_stmt));
  for (int64_t i = 0; OB_SUCC(ret) && i < params_.param_list_->count(); ++i) {
    if (OB_FAIL(anonymous_stmt->add_param(params_.param_list_->at(i)))) {
      LOG_WARN("fail to push back param", K(i), K(ret));
    }
  }
  return ret;
}
}
}