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

#include "sql_parser_base.h"

#define YY_EXTRA_TYPE void *
#define yyconst const
typedef void* yyscan_t;
typedef struct yy_buffer_state *YY_BUFFER_STATE;
extern int obsql_mysql_yylex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals );
extern int obsql_mysql_yyparse(ParseResult *result);
extern int obsql_mysql_multi_fast_parse(ParseResult *p);
extern int obsql_mysql_multi_values_parse(ParseResult *p);
extern int obsql_mysql_fast_parse(ParseResult *p);
extern int obsql_mysql_yylex_destroy (yyscan_t yyscanner );
extern YY_BUFFER_STATE obsql_mysql_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
extern void obsql_mysql_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
extern void obsql_mysql_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
int parse_init(ParseResult *p)
{
  int ret = 0;  // can not include C++ file "ob_define.h"
  static __thread char error_msg[MAX_ERROR_MSG] = {'\0'};
  p->error_msg_ = error_msg;
  if (OB_UNLIKELY(NULL == p || NULL == p->malloc_pool_)) {
    ret = -1;
    if (NULL != p) {
      (void)snprintf(p->error_msg_, MAX_ERROR_MSG, "malloc_pool_ must be set");
    }
  }

  if (OB_LIKELY( 0 == ret)) {
      ret = obsql_mysql_yylex_init_extra(p, &(p->yyscan_info_));
  }
  return ret;
}

int parse_terminate(ParseResult *p)
{
  int ret = 0;
  if (OB_LIKELY(NULL != p->yyscan_info_)) {
      ret = obsql_mysql_yylex_destroy(p->yyscan_info_);
  }
  return ret;
}

int parse_sql(ParseResult *p, const char *buf, size_t len)
{
  int ret = OB_PARSER_ERR_PARSE_SQL;
  if (OB_UNLIKELY(NULL == p)) {
  } else if (OB_UNLIKELY(NULL == buf || len <= 0)) {
    snprintf(p->error_msg_, MAX_ERROR_MSG, "Input SQL can not be empty");
    ret = OB_PARSER_ERR_EMPTY_QUERY;
  } else {
    p->input_sql_ = buf;
    p->input_sql_len_ = len;
    p->start_col_ = 1;
    p->end_col_ = 1;
    p->line_ = 1;
    p->yycolumn_ = 1;
    p->yylineno_ = 1;
#ifdef SQL_PARSER_COMPILATION
    p->realloc_cnt_ = p->realloc_cnt_ <= 0 ? 10 : p->realloc_cnt_;
    p->comment_cap_ = p->realloc_cnt_;
    p->comment_cnt_ = 0;
    p->stop_add_comment_ = false;
#endif
    if (false == p->pl_parse_info_.is_pl_parse_) {//如果是PLParse调用的该接口，不去重置
      p->question_mark_ctx_.count_ = 0;
    }

    // 删除SQL语句末尾的空格 (外层已做)
    // while (len > 0 && ISSPACE(buf[len - 1])) {
    //  --len;
    // }

    //if (OB_UNLIKELY(len <= 0)) {
    // (void)snprintf(p->error_msg_, MAX_ERROR_MSG, "Input SQL can not be white space only");
    //  ret = OB_PARSER_ERR_EMPTY_QUERY;
  //  } else {
    {
      static __thread jmp_buf jmp_buf_;
      p->jmp_buf_ = &jmp_buf_;
      int val = setjmp(*(p->jmp_buf_));
      if (val) {
        if (p->extra_errno_ == OB_PARSER_ERR_NO_MEMORY) {
          // for error other than NO_MEMORY, we return OB_PARSER_ERR_PARSE_SQL to avoid lost connection.
          ret = OB_PARSER_ERR_NO_MEMORY;
        } else {
          ret = OB_PARSER_ERR_PARSE_SQL;
        }
#ifdef SQL_PARSER_COMPILATION
      } else if (OB_ISNULL(p->comment_list_ = (TokenPosInfo*)(parse_malloc(
                                                p->realloc_cnt_ * sizeof(TokenPosInfo),
                                                p->malloc_pool_)))) {
        ret = OB_PARSER_ERR_NO_MEMORY;
#endif
      } else {
          YY_BUFFER_STATE bp = obsql_mysql_yy_scan_bytes(buf, len, p->yyscan_info_);
          obsql_mysql_yy_switch_to_buffer(bp, p->yyscan_info_);
          int tmp_ret = -1;
          if (p->is_fp_) {
            tmp_ret = obsql_mysql_fast_parse(p);
          } else if (p->is_multi_query_) {
            tmp_ret = obsql_mysql_multi_fast_parse(p);
          } else if (p->is_multi_values_parser_) {
            tmp_ret = obsql_mysql_multi_values_parse(p);
          } else {
            tmp_ret = obsql_mysql_yyparse(p);
          }
          if (0 == tmp_ret) {
            ret = OB_PARSER_SUCCESS;
          } else if (2 == tmp_ret) {
            ret = OB_PARSER_ERR_NO_MEMORY;
          } else {
            if (0 != p->extra_errno_) {
              ret = p->extra_errno_;
            } else {
              ret = OB_PARSER_ERR_PARSE_SQL;
            }
          }
          obsql_mysql_yy_delete_buffer(bp, p->yyscan_info_);
      }
    }
  }
  return ret;
}

int parse_sql_stmt(ParseResult *parse_result)
{
  int ret = -1;
  if (0 != (ret = parse_init(parse_result))) {
    // fix bug #16298144
    // fprintf(stderr, "init parse result failed, ret=%d\n", ret);
  } else if (0 != (ret = parse_sql(parse_result, parse_result->input_sql_, parse_result->input_sql_len_))) {
    // fix bug #16298144
    // fprintf(stderr, "parse sql failed, ret=%d, input_sql=%.*s\n", ret, parse_result->input_sql_len_, parse_result->input_sql_);
  }
  return ret;
}

void setup_token_pos_info(ParseNode *node, int off, int len)
{
#ifdef SQL_PARSER_COMPILATION
  node->token_off_ = off;
  node->token_len_ = len;
#else
  // do nothing
#endif
}

int setup_token_pos_info_and_dup_string(ParseNode *node,
                                        ParseResult *result,
                                        int start,
                                        int end)
{
  int ret = OB_PARSER_SUCCESS;
#ifdef SQL_PARSER_COMPILATION
  node->token_off_ = start - 1;
  node->token_len_ = end - start + 1;
  if (start > end) {
    ret = OB_PARSER_ERR_UNEXPECTED;
  } else if (OB_UNLIKELY((NULL == (node->str_value_ = copy_expr_string(result,
                                                                       start,
                                                                       end))))) {
    ret = OB_PARSER_ERR_NO_MEMORY;
  } else {
    node->str_len_ = end - start + 1;
  }
#else
  // do nothing
#endif
  return ret;
}

#ifdef SQL_PARSER_COMPILATION
int add_comment_list(ParseResult *p, const TokenPosInfo *info)
{
  int ret = OB_PARSER_SUCCESS;
  if (OB_ISNULL(p) || OB_ISNULL(info)) {
    ret = OB_PARSER_ERR_UNEXPECTED;
  }
  if (OB_PARSER_SUCCESS == ret && p->comment_cnt_ + 1 >= p->comment_cap_) {
    int alloc_cnt = p->comment_cnt_ + p->realloc_cnt_;
    char *buf = parse_malloc(sizeof(TokenPosInfo) * alloc_cnt, p->malloc_pool_);
    if (OB_ISNULL(buf)) {
      ret = OB_PARSER_ERR_NO_MEMORY;
    } else {
      memset(buf, 0, sizeof(TokenPosInfo) * alloc_cnt);
      memcpy(buf, (void*)(p->comment_list_), sizeof(TokenPosInfo) * p->comment_cnt_);
      p->comment_list_ = (TokenPosInfo*)buf;
      p->comment_cap_ += p->realloc_cnt_;
    }
  }
  if (OB_PARSER_SUCCESS == ret) {
    p->comment_list_[p->comment_cnt_].token_off_ = info->token_off_;
    p->comment_list_[p->comment_cnt_].token_len_ = info->token_len_;
    p->comment_cnt_ += 1;
  }
  return ret;
}
#endif

void REPUT_NEG_SIGN(ParseResult *p)
{
  if (p->minus_ctx_.has_minus_) {
    int start_pos = p->no_param_sql_len_;
    int end_pos = p->minus_ctx_.pos_;
    for (; start_pos > end_pos; start_pos--) {
      p->no_param_sql_[start_pos] = p->no_param_sql_[start_pos - 1];
    }
    p->no_param_sql_[end_pos] = '-';
    p->no_param_sql_[++p->no_param_sql_len_] = '\0';
    p->minus_ctx_.pos_ = -1;
    p->minus_ctx_.raw_sql_offset_ = -1;
    p->minus_ctx_.has_minus_ = false;
  }
}

int STORE_PARAM_NODE_NEED_PARAMETERIZE(ParamList *param,
    struct _ParseNode *node, ParseResult *p, const int first_column)
{
  if (p->minus_ctx_.has_minus_ && p->minus_ctx_.is_cur_numeric_) {
    p->no_param_sql_[p->minus_ctx_.pos_] = '?';
    p->no_param_sql_len_ = p->minus_ctx_.pos_ + 1;
  } else {
    REPUT_NEG_SIGN(p);
    p->no_param_sql_[p->no_param_sql_len_++] = '?';
  }
  p->no_param_sql_[p->no_param_sql_len_] = '\0';
  node->pos_ = p->no_param_sql_len_ - 1;
  node->raw_sql_offset_ = (p->minus_ctx_.has_minus_
      && p->minus_ctx_.is_cur_numeric_) ?
          p->minus_ctx_.raw_sql_offset_ : first_column - 1;
  param->node_ = node;
  param->next_ = NULL;
  if (NULL == p->param_nodes_) {
    p->param_nodes_ = param;
  } else {
    p->tail_param_node_->next_ = param;
  }
  p->tail_param_node_ = param;
  p->param_node_num_++;
  p->token_num_++;
  p->minus_ctx_.has_minus_ = false;
  p->minus_ctx_.pos_ = -1;
  p->minus_ctx_.is_cur_numeric_ = false;
  p->minus_ctx_.raw_sql_offset_ = -1;
  return 0;
}

int add_alias_name(ParseNode *node, ParseResult *result, int end)
{
  int ret = OB_PARSER_SUCCESS;
  if (NULL == node || NULL == result || NULL == node->str_value_) {
    ret = OB_PARSER_ERR_UNEXPECTED;
  } else {
    int need_len = strlen(" as ") + node->str_len_ + 2 * strlen("\"");
    if (end > result->pl_parse_info_.last_pl_symbol_pos_) {
      need_len += end - result->pl_parse_info_.last_pl_symbol_pos_;
    }
    for (int i = 0; i < node->str_len_; ++i) {
      if ('\"' == node->str_value_[i] && !(i > 0 && '\\' == node->str_value_[i - 1])) {
        need_len++;
      }
    }
    if (result->no_param_sql_len_ + need_len >= result->no_param_sql_buf_len_) {
      char *buf = parse_malloc(result->no_param_sql_buf_len_ * 2, result->malloc_pool_);
      if (OB_UNLIKELY(NULL == buf)) {
        ret = OB_PARSER_ERR_NO_MEMORY;
      } else {
        memmove(buf, result->no_param_sql_, result->no_param_sql_len_);
        result->no_param_sql_ = buf;
        result->no_param_sql_buf_len_ = result->no_param_sql_buf_len_ * 2;
      }
    }
    if (OB_PARSER_SUCCESS == ret) {
      if (end > result->pl_parse_info_.last_pl_symbol_pos_) {
        memmove(result->no_param_sql_ + result->no_param_sql_len_, result->input_sql_ + result->pl_parse_info_.last_pl_symbol_pos_, end - result->pl_parse_info_.last_pl_symbol_pos_);
        result->no_param_sql_len_ += end - result->pl_parse_info_.last_pl_symbol_pos_;
        result->pl_parse_info_.last_pl_symbol_pos_ = end;
      }
      result->no_param_sql_len_ += sprintf(result->no_param_sql_ + result->no_param_sql_len_, "%.*s", (int)strlen(" as "), " as ");
      result->no_param_sql_len_ += sprintf(result->no_param_sql_ + result->no_param_sql_len_, "%.*s", (int)strlen("\""), "\"");
      int index1 = 0;
      int index2 = 0;
      char *trans_buf = parse_malloc((int)node->str_len_ * 2, result->malloc_pool_);
      if (OB_UNLIKELY(NULL == trans_buf)) {
        ret = OB_PARSER_ERR_NO_MEMORY;
      } else {
        for (; index1 < node->str_len_; index1++) {
          if ('\"' == node->str_value_[index1] && !(index1 > 0 && '\\' == node->str_value_[index1 - 1])) {
            trans_buf[index2++] = '\\';
            trans_buf[index2++] = '\"';
          } else {
            trans_buf[index2++] = node->str_value_[index1];
          }
        }
        result->no_param_sql_len_ += sprintf(result->no_param_sql_ + result->no_param_sql_len_, "%.*s", index2, trans_buf);
        result->no_param_sql_len_ += sprintf(result->no_param_sql_ + result->no_param_sql_len_, "%.*s", (int)strlen("\""), "\"");
      }
    }
  }
  return ret;
}