package gudusoft.gsqlparser.parser;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.TCustomLexer;
import gudusoft.gsqlparser.TCustomParser;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TLexerBigquery;
import gudusoft.gsqlparser.TParserBigquery;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSourceTokenList;
import gudusoft.gsqlparser.TStatementList;
import gudusoft.gsqlparser.TSyntaxError;
import gudusoft.gsqlparser.EFindSqlStateType;
import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.ETokenStatus;
import gudusoft.gsqlparser.ESqlStatementType;
import gudusoft.gsqlparser.EErrorType;
import gudusoft.gsqlparser.stmt.TUnknownSqlStatement;
import gudusoft.gsqlparser.stmt.TCommonStoredProcedureSqlStatement;
import gudusoft.gsqlparser.stmt.oracle.TSqlplusCmdStatement;
import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreatePackage;
import gudusoft.gsqlparser.nodes.TTypeName;
import gudusoft.gsqlparser.sqlcmds.ISqlCmds;
import gudusoft.gsqlparser.sqlcmds.SqlCmdsFactory;
import gudusoft.gsqlparser.compiler.TContext;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.compiler.TGlobalScope;
import gudusoft.gsqlparser.compiler.TFrame;
import gudusoft.gsqlparser.resolver.TSQLResolver;
import gudusoft.gsqlparser.TLog;
import gudusoft.gsqlparser.compiler.TASTEvaluator;

import java.io.BufferedReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Stack;

import static gudusoft.gsqlparser.ESqlStatementType.*;

/**
 * Google BigQuery SQL parser implementation.
 *
 * <p>This parser handles BigQuery-specific SQL syntax including:
 * <ul>
 *   <li>BigQuery scripting language (BEGIN...END blocks, IF/WHILE/FOR/LOOP/REPEAT statements)</li>
 *   <li>BigQuery UDFs (CREATE FUNCTION with SQL or JavaScript)</li>
 *   <li>BigQuery procedures (CREATE PROCEDURE with BEGIN...END blocks)</li>
 *   <li>Special type handling (STRUCT, ARRAY, DATE/TIME/TIMESTAMP literals)</li>
 *   <li>Backtick-quoted identifiers including qualified names (`schema.table`)</li>
 *   <li>BigQuery-specific keywords and functions</li>
 * </ul>
 *
 * <p><b>Design Notes:</b>
 * <ul>
 *   <li>Extends {@link AbstractSqlParser} using the template method pattern</li>
 *   <li>Uses {@link TLexerBigquery} for tokenization</li>
 *   <li>Uses {@link TParserBigquery} for parsing</li>
 *   <li>Delimiter character: ';' for SQL statements</li>
 *   <li>Splits backtick-quoted qualified names (`schema.table`) into individual tokens</li>
 * </ul>
 *
 * <p><b>Usage Example:</b>
 * <pre>
 * // Get BigQuery parser from factory
 * SqlParser parser = SqlParserFactory.get(EDbVendor.dbvbigquery);
 *
 * // Build context
 * ParserContext context = new ParserContext.Builder(EDbVendor.dbvbigquery)
 *     .sqlText("SELECT * FROM `project.dataset.table` WHERE region = 'US'")
 *     .build();
 *
 * // Parse
 * SqlParseResult result = parser.parse(context);
 *
 * // Access statements
 * TStatementList statements = result.getSqlStatements();
 * </pre>
 *
 * @see SqlParser
 * @see AbstractSqlParser
 * @see TLexerBigquery
 * @see TParserBigquery
 * @since 3.2.0.0
 */
public class BigQuerySqlParser extends AbstractSqlParser {

    /**
     * Construct BigQuery SQL parser.
     * <p>
     * Configures the parser for BigQuery database with default delimiter (;).
     * <p>
     * Following the original TGSqlParser pattern, the lexer and parser are
     * created once in the constructor and reused for all parsing operations.
     */
    public BigQuerySqlParser() {
        super(EDbVendor.dbvbigquery);
        this.delimiterChar = ';';
        this.defaultDelimiterStr = ";";

        // Create lexer once - will be reused for all parsing operations
        this.flexer = new TLexerBigquery();
        this.flexer.delimiterchar = this.delimiterChar;
        this.flexer.defaultDelimiterStr = this.defaultDelimiterStr;

        // Set parent's lexer reference for shared tokenization logic
        this.lexer = this.flexer;

        // Create parser once - will be reused for all parsing operations
        this.fparser = new TParserBigquery(null);
        this.fparser.lexer = this.flexer;
    }

    // ========== Parser Components ==========

    /** The BigQuery lexer used for tokenization */
    public TLexerBigquery flexer;

    /** SQL parser (for BigQuery statements) */
    private TParserBigquery fparser;

    /** Current statement being built during extraction */
    private TCustomSqlStatement gcurrentsqlstatement;

    /** Parser context for current operation */
    private ParserContext parserContext;

    /** User-defined delimiter string for MySQL DELIMITER command */
    private String userDelimiterStr;

    // Stored procedure parsing state tracking
    private enum stored_procedure_type {
        procedure, function, package_spec, package_body, block_with_declare,
        block_with_begin, create_trigger, create_library, others
    }

    private enum stored_procedure_status {
        start, is_as, body, bodyend, end
    }

    private static final int stored_procedure_nested_level = 50;

    // Note: Global context and frame stack fields inherited from AbstractSqlParser:
    // - protected TContext globalContext
    // - protected TSQLEnv sqlEnv
    // - protected Stack<TFrame> frameStack
    // - protected TFrame globalFrame

    // ========== AbstractSqlParser Abstract Methods Implementation ==========

    /**
     * Return the BigQuery lexer instance.
     */
    @Override
    protected TCustomLexer getLexer(ParserContext context) {
        return this.flexer;
    }

    /**
     * Return the BigQuery SQL parser instance with updated token list.
     */
    @Override
    protected TCustomParser getParser(ParserContext context, TSourceTokenList tokens) {
        this.fparser.sourcetokenlist = tokens;
        return this.fparser;
    }

    /**
     * BigQuery does not use a secondary parser (unlike Oracle with PL/SQL).
     */
    @Override
    protected TCustomParser getSecondaryParser(ParserContext context, TSourceTokenList tokens) {
        return null;
    }

    /**
     * Call BigQuery-specific tokenization logic.
     * <p>
     * Delegates to dobigquerysqltexttotokenlist which handles BigQuery's
     * specific keyword recognition, backtick-quoted identifiers, and
     * qualified name splitting.
     */
    @Override
    protected void tokenizeVendorSql() {
        dobigquerysqltexttotokenlist();
    }

    /**
     * Setup BigQuery parser for raw statement extraction.
     * <p>
     * BigQuery uses a single parser, so we inject sqlcmds and update
     * the token list for the main parser only.
     */
    @Override
    protected void setupVendorParsersForExtraction() {
        // Inject sqlcmds into parser (required for make_stmt)
        this.fparser.sqlcmds = this.sqlcmds;

        // Update token list for parser
        this.fparser.sourcetokenlist = this.sourcetokenlist;
    }

    /**
     * Call BigQuery-specific raw statement extraction logic.
     * <p>
     * Delegates to dobigquerygetrawsqlstatements which handles BigQuery's
     * statement delimiters and scripting language boundaries (BEGIN...END blocks,
     * IF/WHILE/FOR/LOOP statements).
     */
    @Override
    protected void extractVendorRawStatements(SqlParseResult.Builder builder) {
        int errorCount = dobigquerygetrawsqlstatements(builder);
        // Error count is tracked internally; errors are already added to syntaxErrors list

        // Set the extracted statements in the builder
        builder.sqlStatements(this.sqlstatements);
    }

    // ========== Tokenization Methods ==========

    /**
     * Tokenize BigQuery SQL text into a list of tokens.
     * <p>
     * This method handles BigQuery-specific token processing:
     * <ul>
     *   <li>Splits backtick-quoted qualified names (`schema.table`) into separate tokens</li>
     *   <li>Handles all standard SQL tokens (keywords, identifiers, operators, etc.)</li>
     * </ul>
     * <p>
     * Migrated from TGSqlParser.dobigquerysqltexttotokenlist()
     */
    private void dobigquerysqltexttotokenlist() {
        TSourceToken asourcetoken, lcprevst;
        int yychar;

        flexer.tmpDelimiter = "";

        asourcetoken = getanewsourcetoken();
        if (asourcetoken == null) return;
        yychar = asourcetoken.tokencode;

        while (yychar > 0) {
            if (asourcetoken != null) {
                sourcetokenlist.add(asourcetoken);
            }

            asourcetoken = getanewsourcetoken();
            if (asourcetoken == null) break;
            yychar = asourcetoken.tokencode;

            // `schema.table_name` - split into separate tokens
            if ((asourcetoken.tokencode == TBaseType.ident)
                    && (asourcetoken.toString().startsWith("`")) && (asourcetoken.toString().endsWith("`"))
                    && (asourcetoken.toString().indexOf(".") > 0)) {
                yychar = splitQualifiedNameInBacktick(asourcetoken);
                asourcetoken = null;
            }
        }
    }

    /**
     * Turn one token: `schema.table_name` into 3 tokens: `schema` . `table_name`
     * <p>
     * This helper method splits backtick-quoted qualified names into individual
     * identifier and period tokens, preserving line/column information for each part.
     * <p>
     * Migrated from TGSqlParser.splitQualifiedNameInBacktick()
     *
     * @param asourcetoken the token to split
     * @return the token code of the last token created
     */
    private int splitQualifiedNameInBacktick(TSourceToken asourcetoken) {
        int yychar = 0;

        List<String> elephantList = Arrays.asList(TBaseType.getTextWithoutQuoted(asourcetoken.toString()).split("\\."));
        int p = 0, offset = 0;
        for (String s : elephantList) {
            TSourceToken pst = new TSourceToken("`" + s + "`");
            pst.tokencode = asourcetoken.tokencode;
            pst.tokentype = asourcetoken.tokentype;
            pst.tokenstatus = asourcetoken.tokenstatus;
            pst.splitFrom = asourcetoken;
            pst.lineNo = asourcetoken.lineNo;
            pst.columnNo = asourcetoken.columnNo + offset;
            if (p == 0) offset++; // this count the first ` token
            offset = offset + s.length();
            pst.container = sourcetokenlist;
            if (p > 0) { // 第一个token使用被拆分前那个token的位置，从第二个开始的token，需要先把列表的位置指针加 1
                sourcetokenlist.curpos = sourcetokenlist.curpos + 1;
            }
            pst.posinlist = sourcetokenlist.curpos;

            sourcetokenlist.add(pst);
            yychar = pst.tokencode;

            if (p != elephantList.size() - 1) {
                //`schema.table_name`, add period token in the middle of the backtick included identifier.
                TSourceToken periodst = new TSourceToken(".");
                periodst.tokencode = '.';
                periodst.tokentype = ETokenType.ttperiod;
                periodst.tokenstatus = asourcetoken.tokenstatus;
                periodst.splitFrom = asourcetoken;
                periodst.lineNo = asourcetoken.lineNo;
                periodst.columnNo = asourcetoken.columnNo + offset;
                offset++;
                periodst.container = sourcetokenlist;
                sourcetokenlist.curpos = sourcetokenlist.curpos + 1;
                periodst.posinlist = sourcetokenlist.curpos;
                sourcetokenlist.add(periodst);
                yychar = periodst.tokencode;
            }

            p++;
        }

        return yychar;
    }

    // ========== Raw Statement Extraction ==========

    /**
     * Check if token code is one that pairs with END keyword.
     * <p>
     * Used for BigQuery scripting language to track nested BEGIN/IF/CASE/LOOP/WHILE/FOR/REPEAT blocks.
     * <p>
     * Migrated from TGSqlParser.checkTokenPairWithEnd()
     */
    private boolean checkTokenPairWithEnd(int tokencode) {
        return ((tokencode == TBaseType.rrw_if) || (tokencode == TBaseType.rrw_case)
                || (tokencode == TBaseType.rrw_loop) || (tokencode == TBaseType.rrw_repeat)
                || (tokencode == TBaseType.rrw_while) || (tokencode == TBaseType.rrw_for)
                || (tokencode == TBaseType.rrw_case));
    }

    /**
     * Extract raw SQL statements from the token list.
     * <p>
     * This method separates individual SQL statements without full syntax checking.
     * It handles BigQuery-specific syntax including:
     * <ul>
     *   <li>Stored procedures and functions with BEGIN...END blocks</li>
     *   <li>Scripting language statements (IF, WHILE, FOR, LOOP, REPEAT, CASE)</li>
     *   <li>STRUCT constructor special handling</li>
     *   <li>Type casting with literals (DATE '2021-01-01')</li>
     *   <li>Nested procedure tracking</li>
     * </ul>
     * <p>
     * Migrated from TGSqlParser.dobigquerygetrawsqlstatements()
     *
     * @param builder the result builder to populate
     * @return error count
     */
    private int dobigquerygetrawsqlstatements(SqlParseResult.Builder builder) {
        int errorcount = 0;
        gcurrentsqlstatement = null;
        EFindSqlStateType gst = EFindSqlStateType.stnormal;
        int i, c, beginNested = 0, waitingEnd = 0;
        TSourceToken ast = null, lcprevsolidtoken = null;
        boolean waitingDelimiter = false;

        int waitingEnds[] = new int[stored_procedure_nested_level];
        stored_procedure_type sptype[] = new stored_procedure_type[stored_procedure_nested_level];
        stored_procedure_status procedure_status[] = new stored_procedure_status[stored_procedure_nested_level];
        boolean endBySlashOnly = true;
        int nestedProcedures = 0, nestedParenthesis = 0;

        //reset delimiter
        userDelimiterStr = defaultDelimiterStr;

        for (i = 0; i < sourcetokenlist.size(); i++) {
            if ((ast != null) && (ast.issolidtoken()))
                lcprevsolidtoken = ast;

            ast = sourcetokenlist.get(i);
            sourcetokenlist.curpos = i;

            // Handle STRUCT constructor: STRUCT(...) -> mark as struct constructor
            if (ast.tokencode == TBaseType.rrw_bigquery_struct) {
                TSourceToken st1 = ast.nextSolidToken();
                if (st1 != null) {
                    if (st1.tokencode == '(') {
                        ast.tokencode = TBaseType.rrw_bigquery_struct_constructor;
                    }
                }
            }
            // Handle type casting: DATE '2021-01-01' -> mark DATE as datatype used to cast
            else if ((ast.tokencode == TBaseType.sconst)) {
                if (lcprevsolidtoken != null && TTypeName.searchTypeByName(lcprevsolidtoken.toString()) != null) {
                    if (lcprevsolidtoken.tokencode != TBaseType.rrw_interval) {
                        lcprevsolidtoken.tokencode = TBaseType.rrw_bigquery_datatype_used_to_cast;
                    }
                }
            }
            // Handle TIME/DATE: could be function or type literal
            else if ((ast.tokencode == TBaseType.rrw_time) || (ast.tokencode == TBaseType.rrw_date)) {
                TSourceToken st1 = ast.nextSolidToken();
                if (st1 != null) {
                    if (st1.tokencode == TBaseType.sconst) {
                        // ast.tokencode = TBaseType.rrw_bigquery_time_before_const;
                    } else if (st1.tokencode == '(') {
                        ast.tokencode = TBaseType.ident;
                    }
                }
            }
            // Handle FROM after period: i.from -> treat FROM as identifier
            else if (ast.tokencode == TBaseType.rrw_from) {
                TSourceToken st1 = ast.prevSolidToken();
                if (st1 != null) { // select i.from as `from` from t, treats from in i.from as identifier
                    if (st1.tokencode == '.') {
                        ast.tokencode = TBaseType.ident;
                    }
                }
            }
            // Handle TIMESTAMP: distinguish type from identifier based on context
            else if (ast.tokencode == TBaseType.rrw_timestamp) {
                TSourceToken prevToken = ast.prevSolidToken();
                TSourceToken nextToken = ast.nextSolidToken();

                // Check if preceded by period -> identifier (e.g., table.timestamp)
                if (prevToken != null && prevToken.tokencode == '.') {
                    // Keep as RW_TIMESTAMP (will be used as identifier via unreserved_keyword)
                }
                // Check type contexts where TIMESTAMP should be marked as type
                else if (prevToken != null &&
                        (prevToken.tokencode == TBaseType.rrw_as ||          // CAST(x AS TIMESTAMP)
                         prevToken.tokencode == ',' ||                        // func(INT, TIMESTAMP)
                         prevToken.tokencode == '(' ||                        // CAST(TIMESTAMP ...), STRUCT(col TIMESTAMP)
                         prevToken.tokencode == '<' ||                        // ARRAY<TIMESTAMP>, STRUCT<col TIMESTAMP>
                         prevToken.tokencode == TBaseType.ident)) {          // column_name TIMESTAMP (column definition)
                    ast.tokencode = TBaseType.rrw_bigquery_timestamp_as_type;
                }
                // Check if followed by '(' with precision -> type constructor TIMESTAMP(6)
                else if (nextToken != null && nextToken.tokencode == '(') {
                    TSourceToken afterParen = nextToken.nextSolidToken();
                    if (afterParen != null &&
                        (afterParen.tokencode == TBaseType.iconst ||         // TIMESTAMP(6)
                         afterParen.tokencode == ')')) {                      // TIMESTAMP()
                        ast.tokencode = TBaseType.rrw_bigquery_timestamp_as_type;
                    }
                }
                // Check if followed by common tokens after type declarations
                else if (nextToken != null &&
                        (nextToken.tokencode == ',' ||                        // col TIMESTAMP, another
                         nextToken.tokencode == ')' ||                        // col TIMESTAMP)
                         nextToken.tokencode == '>' ||                        // ARRAY<TIMESTAMP>
                         nextToken.tokencode == TBaseType.rrw_not ||         // TIMESTAMP NOT NULL
                         nextToken.tokencode == TBaseType.rrw_null)) {       // TIMESTAMP NULL
                    ast.tokencode = TBaseType.rrw_bigquery_timestamp_as_type;
                }
            }
            // Handle LEFT/INNER/FULL prefixing a set operation (LEFT [OUTER] UNION ...):
            // rewrite to synthetic *_SET_OP tokens so the grammar can tell a set-op
            // prefix apart from a join keyword after a parenthesized subquery
            else if ((ast.tokencode == TBaseType.rrw_left)
                    || (ast.tokencode == TBaseType.rrw_inner)
                    || (ast.tokencode == TBaseType.rrw_full)) {
                TSourceToken prevToken = ast.prevSolidToken();
                // t.LEFT / t.FULL are qualified-name segments, never set-op prefixes
                if (prevToken == null || prevToken.tokencode != '.') {
                    TSourceToken st1 = ast.nextSolidToken();
                    // LEFT/FULL allow an optional OUTER before UNION; INNER does not
                    if ((st1 != null) && (st1.tokencode == TBaseType.rrw_outer)
                            && (ast.tokencode != TBaseType.rrw_inner)) {
                        st1 = st1.nextSolidToken();
                    }
                    if ((st1 != null) && (st1.tokencode == TBaseType.rrw_union)) {
                        if (ast.tokencode == TBaseType.rrw_left) {
                            ast.tokencode = TBaseType.rrw_bigquery_left_set_op;
                        } else if (ast.tokencode == TBaseType.rrw_inner) {
                            ast.tokencode = TBaseType.rrw_bigquery_inner_set_op;
                        } else {
                            ast.tokencode = TBaseType.rrw_bigquery_full_set_op;
                        }
                    }
                }
            }

            switch (gst) {
                case sterror: {
                    if (ast.tokentype == ETokenType.ttsemicolon) {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        gst = EFindSqlStateType.stnormal;
                    } else {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                    }
                    break;
                }
                case stnormal: {
                    if ((ast.tokencode == TBaseType.cmtdoublehyphen)
                            || (ast.tokencode == TBaseType.cmtslashstar)
                            || (ast.tokencode == TBaseType.lexspace)
                            || (ast.tokencode == TBaseType.lexnewline)
                            || (ast.tokentype == ETokenType.ttsemicolon)) {
                        if (TBaseType.assigned(gcurrentsqlstatement)) {
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                        }

                        continue;
                    }

                    // find a token to start sql or plsql mode
                    gcurrentsqlstatement = sqlcmds.issql(ast, gst, gcurrentsqlstatement);

                    if (TBaseType.assigned(gcurrentsqlstatement)) {
                        if (gcurrentsqlstatement.isBigQueryplsql()) {
                            nestedProcedures = 0;
                            gst = EFindSqlStateType.ststoredprocedure;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);

                            switch (gcurrentsqlstatement.sqlstatementtype) {
                                case sstplsql_createprocedure:
                                case sstcreateprocedure:
                                    sptype[nestedProcedures] = stored_procedure_type.procedure;
                                    break;
                                case sstplsql_createfunction:
                                    sptype[nestedProcedures] = stored_procedure_type.function;
                                    break;
                                case sstplsql_createpackage:
                                    sptype[nestedProcedures] = stored_procedure_type.package_spec;
                                    if (ast.searchToken(TBaseType.rrw_body, 5) != null) {
                                        sptype[nestedProcedures] = stored_procedure_type.package_body;
                                    }
                                    break;
                                case sst_plsql_block:
                                    sptype[nestedProcedures] = stored_procedure_type.block_with_declare;
                                    if (ast.tokencode == TBaseType.rrw_begin) {
                                        sptype[nestedProcedures] = stored_procedure_type.block_with_begin;
                                    }
                                    break;
                                case sstplsql_createtrigger:
                                    sptype[nestedProcedures] = stored_procedure_type.create_trigger;
                                    break;
                                case sstoraclecreatelibrary:
                                    sptype[nestedProcedures] = stored_procedure_type.create_library;
                                    break;
                                case sstplsql_createtype_placeholder:
                                    gst = EFindSqlStateType.stsql;
                                    break;
                                default:
                                    sptype[nestedProcedures] = stored_procedure_type.others;
                                    break;
                            }

                            if (sptype[0] == stored_procedure_type.block_with_declare) {
                                // sd
                                endBySlashOnly = false;
                                procedure_status[0] = stored_procedure_status.is_as;
                            } else if (sptype[0] == stored_procedure_type.block_with_begin) {
                                // sb
                                endBySlashOnly = false;
                                procedure_status[0] = stored_procedure_status.body;
                            } else if (sptype[0] == stored_procedure_type.procedure) {
                                // ss
                                endBySlashOnly = false;
                                procedure_status[0] = stored_procedure_status.start;
                            } else if (sptype[0] == stored_procedure_type.function) {
                                // ss
                                endBySlashOnly = false;
                                procedure_status[0] = stored_procedure_status.start;
                            } else if (sptype[0] == stored_procedure_type.package_spec) {
                                // ss
                                endBySlashOnly = false;
                                procedure_status[0] = stored_procedure_status.start;
                            } else if (sptype[0] == stored_procedure_type.package_body) {
                                // ss
                                endBySlashOnly = false;
                                procedure_status[0] = stored_procedure_status.start;
                            } else if (sptype[0] == stored_procedure_type.create_trigger) {
                                // ss
                                endBySlashOnly = false;
                                procedure_status[0] = stored_procedure_status.start;
                            } else if (sptype[0] == stored_procedure_type.create_library) {
                                // ss
                                endBySlashOnly = false;
                                procedure_status[0] = stored_procedure_status.bodyend;
                            } else {
                                // so
                                endBySlashOnly = true;
                                procedure_status[0] = stored_procedure_status.bodyend;
                            }
                            if ((ast.tokencode == TBaseType.rrw_begin)
                                    || (ast.tokencode == TBaseType.rrw_package)
                                    || (ast.searchToken(TBaseType.rrw_package, 4) != null)) {
                                waitingEnds[nestedProcedures] = 1;
                            }

                        } else if ((gcurrentsqlstatement.sqlstatementtype == sst_ifstmt)
                                || (gcurrentsqlstatement.sqlstatementtype == sst_loopstmt)
                                || (gcurrentsqlstatement.sqlstatementtype == sstRepeat)
                                || (gcurrentsqlstatement.sqlstatementtype == sstWhilestmt)
                                || (gcurrentsqlstatement.sqlstatementtype == sstForStmt)
                                || (gcurrentsqlstatement.sqlstatementtype == sst_plsql_block)
                                || (gcurrentsqlstatement.sqlstatementtype == sst_casestmt)) {
                            gst = EFindSqlStateType.stBigQueryIf;
                            // For labeled statements (label: LOOP/WHILE/etc.), the first token
                            // is the label identifier, and the keyword comes later in stBigQueryIf
                            // where it will increment waitingEnd. So start at 0.
                            waitingEnd = (ast.tokencode == TBaseType.ident) ? 0 : 1;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                        } else {
                            gst = EFindSqlStateType.stsql;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                        }

                    }

                    if (!TBaseType.assigned(gcurrentsqlstatement)) //error token found
                    {
                        this.syntaxErrors.add(new TSyntaxError(ast.getAstext(), ast.lineNo, (ast.columnNo < 0 ? 0 : ast.columnNo)
                                , "Error when tokenlize", EErrorType.spwarning, TBaseType.MSG_WARNING_ERROR_WHEN_TOKENIZE, null, ast.posinlist));

                        ast.tokentype = ETokenType.tttokenlizererrortoken;
                        gst = EFindSqlStateType.sterror;

                        gcurrentsqlstatement = new TUnknownSqlStatement(vendor);
                        gcurrentsqlstatement.sqlstatementtype = ESqlStatementType.sstinvalid;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);

                    }
                    break;
                }
                case stBigQueryIf: {
                    gcurrentsqlstatement.sourcetokenlist.add(ast);

                    if (checkTokenPairWithEnd(ast.tokencode)) { // if... end if
                        if (ast.searchToken(TBaseType.rrw_end, -1) == null) {
                            //this is not if after END
                            waitingEnd++;
                        }
                    } else if (ast.tokencode == TBaseType.rrw_end) { // if ... end if
                        TSourceToken next = ast.nextSolidToken();
                        if (next != null) {
                            if (checkTokenPairWithEnd(next.tokencode)) { // if ... end if;
                                waitingEnd--;
                            } else if (next.tokencode == ';') { // begin ... end ;
                                waitingEnd--;
                            } else if (next.tokencode == TBaseType.ident) {
                                // begin ... end label_name ; (labeled block end)
                                TSourceToken afterLabel = next.nextSolidToken();
                                if (afterLabel != null && afterLabel.tokencode == ';') {
                                    waitingEnd--;
                                }
                            }

                        }
                    } else if ((ast.tokencode == ';') && (waitingEnd == 0)) {
                        gst = EFindSqlStateType.stnormal;

                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                    }
                    break;
                }
                case stsqlplus: {
                    if (ast.tokencode == TBaseType.lexnewline) {
                        gst = EFindSqlStateType.stnormal;
                        gcurrentsqlstatement.sourcetokenlist.add(ast); // so add it here
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                    } else {
                        {
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                        }
                    }

                    break;
                }//case source command or \. command
                case stsql: {
                    if ((ast.tokentype == ETokenType.ttsemicolon) && (gcurrentsqlstatement.sqlstatementtype != ESqlStatementType.sstmysqldelimiter)) {
                        gst = EFindSqlStateType.stnormal;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        gcurrentsqlstatement.semicolonended = ast;
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        continue;
                    }
                    if (ast.toString().equalsIgnoreCase(userDelimiterStr)) {
                        gst = EFindSqlStateType.stnormal;
                        ast.tokencode = ';';// treat it as semicolon
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        gcurrentsqlstatement.semicolonended = ast;
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        continue;
                    }
                    gcurrentsqlstatement.sourcetokenlist.add(ast);

                    if ((ast.tokencode == TBaseType.lexnewline)
                            && (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmysqldelimiter)) {
                        gst = EFindSqlStateType.stnormal;
                        userDelimiterStr = "";
                        for (int k = 0; k < gcurrentsqlstatement.sourcetokenlist.size(); k++) {
                            TSourceToken st = gcurrentsqlstatement.sourcetokenlist.get(k);
                            if ((st.tokencode == TBaseType.rrw_mysql_delimiter)
                                    || (st.tokencode == TBaseType.lexnewline)
                                    || (st.tokencode == TBaseType.lexspace)) {
                                continue;
                            }

                            userDelimiterStr += st.toString();
                        }
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);

                        continue;
                    }

                    break;
                }
                case ststoredprocedure: {
                    if (procedure_status[nestedProcedures] != stored_procedure_status.bodyend) {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                    }

                    switch (procedure_status[nestedProcedures]) {
                        case start:
                            if ((ast.tokencode == TBaseType.rrw_as) || (ast.tokencode == TBaseType.rrw_is)) {
                                // s1
                                if (sptype[nestedProcedures] != stored_procedure_type.create_trigger) {
                                    if ((sptype[0] == stored_procedure_type.package_spec) && (nestedProcedures > 0)) {
                                        //when it's a package specification, only top level accept as/is
                                    } else {
                                        procedure_status[nestedProcedures] = stored_procedure_status.is_as;
                                        if (ast.searchToken("language", 1) != null) {
                                            if (nestedProcedures == 0) {
                                                gst = EFindSqlStateType.stsql;
                                            } else {
                                                procedure_status[nestedProcedures] = stored_procedure_status.body;
                                                nestedProcedures--;
                                            }

                                        }
                                    }
                                }
                            } else if (ast.tokencode == TBaseType.rrw_begin) {
                                // s4
                                if (sptype[nestedProcedures] == stored_procedure_type.create_trigger)
                                    waitingEnds[nestedProcedures]++;

                                if (nestedProcedures > 0) {
                                    nestedProcedures--;
                                }
                                procedure_status[nestedProcedures] = stored_procedure_status.body;
                                waitingEnds[nestedProcedures] = 1;
                            } else if (ast.tokencode == TBaseType.rrw_end) {
                                //s10
                                if ((nestedProcedures > 0) && (waitingEnds[nestedProcedures - 1] == 1)
                                        && ((sptype[nestedProcedures - 1] == stored_procedure_type.package_body)
                                        || (sptype[nestedProcedures - 1] == stored_procedure_type.package_spec))) {
                                    nestedProcedures--;
                                    procedure_status[nestedProcedures] = stored_procedure_status.bodyend;
                                }
                            } else if ((ast.tokencode == TBaseType.rrw_procedure) || (ast.tokencode == TBaseType.rrw_function)) {
                                //s3
                                if ((nestedProcedures > 0) && (waitingEnds[nestedProcedures] == 0)
                                        && (procedure_status[nestedProcedures - 1] == stored_procedure_status.is_as)) {
                                    nestedProcedures--;
                                    nestedProcedures++;
                                    waitingEnds[nestedProcedures] = 0;
                                    procedure_status[nestedProcedures] = stored_procedure_status.start;
                                }
                            } else if ((sptype[nestedProcedures] == stored_procedure_type.create_trigger) && (ast.tokencode == TBaseType.rrw_declare)) {
                                procedure_status[nestedProcedures] = stored_procedure_status.is_as;
                            } else if ((sptype[nestedProcedures] == stored_procedure_type.create_trigger) && (ast.tokentype == ETokenType.ttslash) && (ast.tokencode == TBaseType.sqlpluscmd)) {
                                ast.tokenstatus = ETokenStatus.tsignorebyyacc;
                                gst = EFindSqlStateType.stnormal;
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);

                                //make / a sqlplus cmd
                                gcurrentsqlstatement = new TSqlplusCmdStatement(vendor);
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            } else if ((sptype[nestedProcedures] == stored_procedure_type.create_trigger)) {
                                if (ast.tokencode == TBaseType.rrw_trigger) {
                                    TSourceToken compoundSt = ast.searchToken(TBaseType.rrw_oracle_compound, -1);
                                    if (compoundSt != null) {
                                        //it's trigger with compound trigger block
                                        procedure_status[nestedProcedures] = stored_procedure_status.body;
                                        waitingEnds[nestedProcedures]++;
                                    }
                                }
                            } else if ((sptype[nestedProcedures] == stored_procedure_type.function) && (ast.tokencode == TBaseType.rrw_teradata_using)) {
                                if ((ast.searchToken("aggregate", -1) != null) || (ast.searchToken("pipelined", -1) != null)) {
                                    if (nestedProcedures == 0) {
                                        gst = EFindSqlStateType.stsql;
                                    } else {
                                        procedure_status[nestedProcedures] = stored_procedure_status.body;
                                        nestedProcedures--;
                                    }
                                }

                            } else {
                                //other tokens, do nothing
                            }
                            break;
                        case is_as:
                            if ((ast.tokencode == TBaseType.rrw_procedure) || (ast.tokencode == TBaseType.rrw_function)) {
                                // s2
                                nestedProcedures++;
                                if (nestedProcedures > stored_procedure_nested_level - 1) {
                                    gst = EFindSqlStateType.sterror;
                                    nestedProcedures--;
                                } else {
                                    waitingEnds[nestedProcedures] = 0;
                                    procedure_status[nestedProcedures] = stored_procedure_status.start;
                                }

                            } else if (ast.tokencode == TBaseType.rrw_begin) {
                                // s5
                                if ((nestedProcedures == 0) &&
                                        ((sptype[nestedProcedures] == stored_procedure_type.package_body)
                                                || (sptype[nestedProcedures] == stored_procedure_type.package_spec))) {
                                    //top level package or package body's BEGIN keyword already count,
                                    // so don't increase waitingEnds[nestedProcedures] here

                                } else {
                                    waitingEnds[nestedProcedures]++;
                                }
                                procedure_status[nestedProcedures] = stored_procedure_status.body;
                            } else if (ast.tokencode == TBaseType.rrw_end) {
                                // s6
                                if ((nestedProcedures == 0) && (waitingEnds[nestedProcedures] == 1) &&
                                        ((sptype[nestedProcedures] == stored_procedure_type.package_body) || (sptype[nestedProcedures] == stored_procedure_type.package_spec))) {
                                    procedure_status[nestedProcedures] = stored_procedure_status.bodyend;
                                    waitingEnds[nestedProcedures]--;
                                } else {
                                    waitingEnds[nestedProcedures]--;
                                }
                            } else if (ast.tokencode == TBaseType.rrw_case) {
                                if (ast.searchToken(';', 1) == null) {
                                    //this is not case before ;
                                    waitingEnds[nestedProcedures]++;
                                }
                            } else {
                                //other tokens, do nothing
                            }
                            break;
                        case body:
                            if ((ast.tokencode == TBaseType.rrw_begin)) {
                                waitingEnds[nestedProcedures]++;
                            } else if (ast.tokencode == TBaseType.rrw_if) {

                                if (ast.searchToken(';', 2) == null) {
                                    //this is not if before ;

                                    // 2015-02-27, change 1 to 2 make it able to detect label name after case
                                    // like this: END CASE l1;
                                    waitingEnds[nestedProcedures]++;
                                }
                            } else if (ast.tokencode == TBaseType.rrw_case) {
                                if (ast.searchToken(';', 2) == null) {
                                    //this is not case before ;
                                    if (ast.searchToken(TBaseType.rrw_end, -1) == null) {
                                        waitingEnds[nestedProcedures]++;
                                    }
                                }
                            } else if ((ast.tokencode == TBaseType.rrw_loop)
                                    || (ast.tokencode == TBaseType.rrw_while) || (ast.tokencode == TBaseType.rrw_repeat)
                                    || (ast.tokencode == TBaseType.rrw_for)) {
                                if (!((ast.searchToken(TBaseType.rrw_end, -1) != null)
                                        && (ast.searchToken(';', 2) != null))) {
                                    // exclude loop like this:
                                    // end loop [labelname];
                                    waitingEnds[nestedProcedures]++;
                                }

                            } else if (ast.tokencode == TBaseType.rrw_end) {
                                //foundEnd = true;
                                waitingEnds[nestedProcedures]--;
                                //if (waitingEnd < 0) { waitingEnd = 0;}
                                if (waitingEnds[nestedProcedures] == 0) {
                                    if (nestedProcedures == 0) {
                                        // s7
                                        procedure_status[nestedProcedures] = stored_procedure_status.bodyend;
                                    } else {
                                        // s71
                                        nestedProcedures--;
                                        procedure_status[nestedProcedures] = stored_procedure_status.is_as;
                                    }
                                }
                            } else if ((waitingEnds[nestedProcedures] == 0) && (ast.tokentype == ETokenType.ttslash) && (ast.tokencode == TBaseType.sqlpluscmd)) {
                                ast.tokenstatus = ETokenStatus.tsignorebyyacc;
                                gst = EFindSqlStateType.stnormal;
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);

                                //make / a sqlplus cmd
                                gcurrentsqlstatement = new TSqlplusCmdStatement(vendor);
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            }
                            break;
                        case bodyend:
                            if ((ast.tokentype == ETokenType.ttslash) && (ast.tokencode == TBaseType.sqlpluscmd)) {
                                ast.tokenstatus = ETokenStatus.tsignorebyyacc;
                                gst = EFindSqlStateType.stnormal;
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);

                                //make / a sqlplus cmd
                                gcurrentsqlstatement = new TSqlplusCmdStatement(vendor);
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            } else if ((ast.tokencode == ';')) {
                                gst = EFindSqlStateType.stnormal;
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);

                            } else if ((ast.searchToken(TBaseType.rrw_package, 1) != null) && (!endBySlashOnly)) {
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                gst = EFindSqlStateType.stnormal;
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            } else if ((ast.searchToken(TBaseType.rrw_procedure, 1) != null) && (!endBySlashOnly)) {
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                gst = EFindSqlStateType.stnormal;
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            } else if ((ast.searchToken(TBaseType.rrw_function, 1) != null) && (!endBySlashOnly)) {
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                gst = EFindSqlStateType.stnormal;
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            } else if ((ast.searchToken(TBaseType.rrw_create, 1) != null) && (ast.searchToken(TBaseType.rrw_package, 4) != null) && (!endBySlashOnly)) {
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                gst = EFindSqlStateType.stnormal;
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            } else if ((ast.searchToken(TBaseType.rrw_create, 1) != null) && (ast.searchToken(TBaseType.rrw_library, 4) != null) && (!endBySlashOnly)) {
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                gst = EFindSqlStateType.stnormal;
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            } else if ((ast.searchToken(TBaseType.rrw_alter, 1) != null) && (ast.searchToken(TBaseType.rrw_trigger, 2) != null) && (!endBySlashOnly)) {
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                gst = EFindSqlStateType.stnormal;
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            } else if ((ast.searchToken(TBaseType.rrw_select, 1) != null) && (!endBySlashOnly)) {
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                gst = EFindSqlStateType.stnormal;
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            } else if ((ast.searchToken(TBaseType.rrw_commit, 1) != null) && (!endBySlashOnly)) {
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                gst = EFindSqlStateType.stnormal;
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            } else if ((ast.searchToken(TBaseType.rrw_grant, 1) != null) &&
                                    (ast.searchToken(TBaseType.rrw_execute, 2) != null) && (!endBySlashOnly)) {
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                gst = EFindSqlStateType.stnormal;
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            } else {
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                            }
                            break;
                        case end:
                            break;
                        default:
                            break;
                    }

                    if (ast.tokencode == TBaseType.sqlpluscmd) {
                        //change tokencode back to keyword or TBaseType.ident, because sqlplus cmd
                        //in a sql statement(almost is plsql block) is not really a sqlplus cmd
                        int m = flexer.getkeywordvalue(ast.getAstext());
                        if (m != 0) {
                            ast.tokencode = m;
                        } else if (ast.tokentype == ETokenType.ttslash) {
                            ast.tokencode = '/';
                        } else {
                            ast.tokencode = TBaseType.ident;
                        }
                    }

                    final int wrapped_keyword_max_pos = 20;
                    if ((ast.tokencode == TBaseType.rrw_wrapped) && (ast.posinlist - gcurrentsqlstatement.sourcetokenlist.get(0).posinlist < wrapped_keyword_max_pos)) {
                        if (gcurrentsqlstatement instanceof TCommonStoredProcedureSqlStatement) {
                            ((TCommonStoredProcedureSqlStatement) gcurrentsqlstatement).setWrapped(true);
                        }

                        if (gcurrentsqlstatement instanceof TPlsqlCreatePackage) {
                            if (ast.prevSolidToken() != null) {
                                ((TPlsqlCreatePackage) gcurrentsqlstatement).setPackageName(fparser.getNf().createObjectNameWithPart(ast.prevSolidToken()));
                            }
                        }
                    }

                    break;
                } //ststoredprocedure

            } //case
        } //for

        //last statement
        if (TBaseType.assigned(gcurrentsqlstatement) &&
                ((gst == EFindSqlStateType.stsql) || (gst == EFindSqlStateType.ststoredprocedure)
                        || (gst == EFindSqlStateType.stBigQueryIf) || (gst == EFindSqlStateType.sterror))) {
            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, true, builder);
        }

        return errorcount;
    }

    // ========== Statement Parsing ==========

    /**
     * Parse all SQL statements after tokenization and raw extraction.
     * <p>
     * This method iterates through all statements, calls parsestatement on each,
     * and handles error recovery for CREATE TABLE statements if enabled.
     * <p>
     * Inherited performParsing pattern from AbstractSqlParser, specialized for BigQuery.
     */
    @Override
    protected TStatementList performParsing(ParserContext context, TCustomParser parser,
                                            TCustomParser secondaryParser, TSourceTokenList tokens,
                                            TStatementList rawStatements) {
        // Store references for error handling
        this.fparser = (TParserBigquery) parser;
        this.sourcetokenlist = tokens;
        this.parserContext = context;
        this.sqlstatements = rawStatements;

        // Initialize sqlcmds for BigQuery
        if (this.sqlcmds == null) {
            this.sqlcmds = SqlCmdsFactory.get(vendor);
        }
        this.fparser.sqlcmds = this.sqlcmds;

        // Initialize global context using inherited method
        initializeGlobalContext();

        // Parse each statement
        for (int i = 0; i < sqlstatements.size(); i++) {
            TCustomSqlStatement stmt = sqlstatements.getRawSql(i);

            try {
                // Set frame stack for variable scope tracking
                stmt.setFrameStack(frameStack);

                // Parse the statement
                int parseResult = stmt.parsestatement(null, false, context.isOnlyNeedRawParseTree());

                // Vendor-specific post-processing (none needed for BigQuery currently)
                afterStatementParsed(stmt);

                // Collect errors from the statement
                if ((parseResult != 0) || (stmt.getErrorCount() > 0)) {
                    copyErrorsFromStatement(stmt);
                }

            } catch (Exception ex) {
                // Use inherited exception handler
                handleStatementParsingException(stmt, i, ex);
                continue;
            }
        }

        // Clean up frame stack
        if (globalFrame != null) {
            globalFrame.popMeFromStack(frameStack);
        }

        return sqlstatements;
    }

    /**
     * Post-process statement after parsing (hook method).
     * <p>
     * BigQuery does not require special post-processing, so this is a no-op.
     * Override if BigQuery-specific validation is needed in the future.
     */
    protected void afterStatementParsed(TCustomSqlStatement stmt) {
        // No special post-processing needed for BigQuery
    }

    // ========== Semantic Analysis ==========

    /**
     * Perform semantic analysis on parsed statements.
     * <p>
     * Runs TSQLResolver to build relationships between tables and columns,
     * resolve references, and perform type checking.
     */
    @Override
    protected void performSemanticAnalysis(ParserContext context, TStatementList statements) {
        if (TBaseType.isEnableResolver() && getSyntaxErrors().isEmpty()) {
            TSQLResolver resolver = new TSQLResolver(globalContext, statements);
            resolver.resolve();
        }
    }

    /**
     * Perform interpretation/evaluation on statements.
     * <p>
     * Runs TASTEvaluator to execute constant expressions and compile-time
     * evaluations.
     */
    @Override
    protected void performInterpreter(ParserContext context, TStatementList statements) {
        // BigQuery does not require interpretation currently
    }

    @Override
    public String toString() {
        return "BigQuerySqlParser{vendor=" + vendor + "}";
    }
}