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.TLexerRedshift;
import gudusoft.gsqlparser.TParserRedshift;
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.oracle.TSqlplusCmdStatement;
import gudusoft.gsqlparser.stmt.TCommonBlock;
import gudusoft.gsqlparser.stmt.TRoutine;
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.List;
import java.util.Stack;

/**
 * Amazon Redshift SQL parser implementation.
 *
 * <p>This parser handles Redshift-specific SQL syntax including:
 * <ul>
 *   <li>PostgreSQL-based syntax (Redshift is based on PostgreSQL 8.0.2)</li>
 *   <li>PL/pgSQL functions and procedures</li>
 *   <li>CREATE FUNCTION with LANGUAGE clause</li>
 *   <li>Function body delimiters ($$)</li>
 *   <li>Redshift-specific types (ARRAY&lt;type&gt;, %ROWTYPE, etc.)</li>
 *   <li>Redshift-specific keywords (FILTER, LANGUAGE, etc.)</li>
 * </ul>
 *
 * <p><b>Design Notes:</b>
 * <ul>
 *   <li>Extends {@link AbstractSqlParser} using the template method pattern</li>
 *   <li>Uses {@link TLexerRedshift} for tokenization</li>
 *   <li>Uses {@link TParserRedshift} for parsing</li>
 *   <li>Delimiter character: ';' for SQL statements</li>
 * </ul>
 *
 * <p><b>Usage Example:</b>
 * <pre>
 * // Get Redshift parser from factory
 * SqlParser parser = SqlParserFactory.get(EDbVendor.dbvredshift);
 *
 * // Build context
 * ParserContext context = new ParserContext.Builder(EDbVendor.dbvredshift)
 *     .sqlText("SELECT * FROM orders WHERE order_date > CURRENT_DATE - 7")
 *     .build();
 *
 * // Parse
 * SqlParseResult result = parser.parse(context);
 *
 * // Access statements
 * TStatementList statements = result.getSqlStatements();
 * </pre>
 *
 * @see SqlParser
 * @see AbstractSqlParser
 * @see TLexerRedshift
 * @see TParserRedshift
 * @since 3.2.0.0
 */
public class RedshiftSqlParser extends AbstractSqlParser {

    /**
     * Construct Redshift SQL parser.
     * <p>
     * Configures the parser for Redshift 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 RedshiftSqlParser() {
        super(EDbVendor.dbvredshift);
        this.delimiterChar = ';';
        this.defaultDelimiterStr = ";";

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

        // CRITICAL: 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 TParserRedshift(null);
        this.fparser.lexer = this.flexer;
    }

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

    /** The Redshift lexer used for tokenization */
    public TLexerRedshift flexer;

    /** SQL parser (for Redshift statements) */
    private TParserRedshift fparser;

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

    // 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 Redshift lexer instance.
     */
    @Override
    protected TCustomLexer getLexer(ParserContext context) {
        return this.flexer;
    }

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

    /**
     * Redshift doesn't have a secondary parser.
     * <p>
     * Only Oracle uses a secondary parser (PL/SQL parser).
     */
    @Override
    protected TCustomParser getSecondaryParser(ParserContext context, TSourceTokenList tokens) {
        return null;
    }

    /**
     * Call Redshift-specific tokenization logic.
     * <p>
     * Delegates to doredshiftsqltexttotokenlist which handles Redshift's
     * specific keyword recognition, PostgreSQL commands, and token generation.
     */
    @Override
    protected void tokenizeVendorSql() {
        doredshiftsqltexttotokenlist();
    }

    /**
     * Setup Redshift parser for raw statement extraction.
     * <p>
     * Redshift 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 Redshift-specific raw statement extraction logic.
     * <p>
     * Delegates to doredshiftgetrawsqlstatements which handles Redshift's
     * statement delimiters (semicolon, function delimiters $$, etc.).
     */
    @Override
    protected void extractVendorRawStatements(SqlParseResult.Builder builder) {
        doredshiftgetrawsqlstatements(builder);

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

    /**
     * Perform full parsing of statements with syntax checking.
     * <p>
     * This method orchestrates the parsing of all statements.
     */
    @Override
    protected TStatementList performParsing(ParserContext context,
                                           TCustomParser parser,
                                           TCustomParser secondaryParser,
                                           TSourceTokenList tokens,
                                           TStatementList rawStatements) {
        // Store references
        this.fparser = (TParserRedshift) parser;
        this.sourcetokenlist = tokens;
        this.parserContext = context;

        // Use the raw statements passed from AbstractSqlParser.parse()
        this.sqlstatements = rawStatements;

        // Initialize sqlcmds (required for parsing)
        this.sqlcmds = SqlCmdsFactory.get(vendor);

        // CRITICAL: Inject sqlcmds into parser (required for make_stmt)
        this.fparser.sqlcmds = this.sqlcmds;

        // Initialize global context for semantic analysis
        initializeGlobalContext();

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

            try {
                // Set frame stack for this statement
                stmt.setFrameStack(frameStack);

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

                // Vendor-specific post-processing (override hook if needed)
                afterStatementParsed(stmt);

                // Error recovery
                boolean doRecover = TBaseType.ENABLE_ERROR_RECOVER_IN_CREATE_TABLE;
                if (doRecover && ((parseResult != 0) || (stmt.getErrorCount() > 0))) {
                    handleCreateTableErrorRecovery(stmt);
                }

                // Collect errors
                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;
    }

    /**
     * Perform semantic analysis on parsed statements.
     * <p>
     * This step resolves column-to-table relationships and performs 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 on parsed statements.
     * <p>
     * This step evaluates constant expressions and performs other interpretation tasks.
     */
    @Override
    protected void performInterpreter(ParserContext context, TStatementList statements) {
        if (TBaseType.ENABLE_INTERPRETER && getSyntaxErrors().isEmpty()) {
            TLog.clearLogs();
            TGlobalScope interpreterScope = new TGlobalScope(sqlEnv);
            TLog.enableInterpreterLogOnly();
            TASTEvaluator astEvaluator = new TASTEvaluator(statements, interpreterScope);
            astEvaluator.eval();
        }
    }

    // ========== Redshift-Specific Tokenization ==========

    /**
     * Tokenize Redshift SQL text to token list.
     * <p>
     * Migrated from TGSqlParser.doredshiftsqltexttotokenlist().
     * <p>
     * This method handles Redshift-specific token processing:
     * <ul>
     *   <li>SQL*Plus-like commands detection</li>
     *   <li>Forward slash (/) disambiguation</li>
     *   <li>%ROWTYPE operator detection</li>
     *   <li>Continuation lines (hyphen at end of line)</li>
     * </ul>
     */
    private void doredshiftsqltexttotokenlist() {
        boolean insqlpluscmd = false;
        boolean isvalidplace = true;
        boolean waitingreturnforfloatdiv = false;
        boolean waitingreturnforsemicolon = false;
        boolean continuesqlplusatnewline = false;

        TSourceToken lct = null, prevst = null;

        TSourceToken asourcetoken, lcprevst;
        int yychar;

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

        while (yychar > 0) {
            sourcetokenlist.add(asourcetoken);
            switch (yychar) {
                case TBaseType.cmtdoublehyphen:
                case TBaseType.cmtslashstar:
                case TBaseType.lexspace: {
                    if (insqlpluscmd) {
                        asourcetoken.insqlpluscmd = true;
                    }
                    break;
                }
                case TBaseType.lexnewline: {
                    if (insqlpluscmd) {
                        insqlpluscmd = false;
                        isvalidplace = true;

                        if (continuesqlplusatnewline) {
                            insqlpluscmd = true;
                            isvalidplace = false;
                            asourcetoken.insqlpluscmd = true;
                        }
                    }

                    if (waitingreturnforsemicolon) {
                        isvalidplace = true;
                    }
                    if (waitingreturnforfloatdiv) {
                        isvalidplace = true;
                        lct.tokencode = TBaseType.sqlpluscmd;
                        if (lct.tokentype != ETokenType.ttslash) {
                            lct.tokentype = ETokenType.ttsqlpluscmd;
                        }
                    }
                    flexer.insqlpluscmd = insqlpluscmd;
                    break;
                } //case newline
                default: {
                    //solid token
                    continuesqlplusatnewline = false;
                    waitingreturnforsemicolon = false;
                    waitingreturnforfloatdiv = false;
                    if (insqlpluscmd) {
                        asourcetoken.insqlpluscmd = true;
                        if (asourcetoken.toString().equalsIgnoreCase("-")) {
                            continuesqlplusatnewline = true;
                        }
                    } else {
                        if (asourcetoken.tokentype == ETokenType.ttsemicolon) {
                            waitingreturnforsemicolon = true;
                        }
                        if ((asourcetoken.tokentype == ETokenType.ttslash)
                                && (isvalidplace || (IsValidPlaceForDivToSqlplusCmd(sourcetokenlist, asourcetoken.posinlist)))) {
                            lct = asourcetoken;
                            waitingreturnforfloatdiv = true;
                        }
                        if ((isvalidplace) && isvalidsqlpluscmdInPostgresql(asourcetoken.toString())) {
                            asourcetoken.tokencode = TBaseType.sqlpluscmd;
                            if (asourcetoken.tokentype != ETokenType.ttslash) {
                                asourcetoken.tokentype = ETokenType.ttsqlpluscmd;
                            }
                            insqlpluscmd = true;
                            flexer.insqlpluscmd = insqlpluscmd;
                        }
                    }
                    isvalidplace = false;

                    // Redshift-specific: Handle %ROWTYPE operator
                    if (asourcetoken.tokencode == TBaseType.rrw_redshift_rowtype) {
                        TSourceToken stPercent = asourcetoken.searchToken('%', -1);
                        if (stPercent != null) {
                            stPercent.tokencode = TBaseType.rowtype_operator;
                        }
                    }
                }
            }

            //flexer.yylexwrap(asourcetoken);
            asourcetoken = getanewsourcetoken();
            if (asourcetoken != null) {
                yychar = asourcetoken.tokencode;
            } else {
                yychar = 0;

                if (waitingreturnforfloatdiv) {
                    // / at the end of line treat as sqlplus command
                    lct.tokencode = TBaseType.sqlpluscmd;
                    if (lct.tokentype != ETokenType.ttslash) {
                        lct.tokentype = ETokenType.ttsqlpluscmd;
                    }
                }
            }

            if ((yychar == 0) && (prevst != null)) {
                // End of input
            }
        } // while
    }

    /**
     * Check if this is a valid place for a forward slash to be treated as a SQL*Plus command.
     * <p>
     * Migrated from TGSqlParser.IsValidPlaceForDivToSqlplusCmd().
     */
    private boolean IsValidPlaceForDivToSqlplusCmd(TSourceTokenList tokenlist, int pos) {
        if (tokenlist == null) return false;
        if (pos <= 0) return true;

        for (int i = pos - 1; i >= 0; i--) {
            TSourceToken st = tokenlist.get(i);
            if (st.tokencode == TBaseType.lexnewline) {
                return true;
            }
            if ((st.tokencode != TBaseType.lexspace)
                    && (st.tokencode != TBaseType.cmtdoublehyphen)
                    && (st.tokencode != TBaseType.cmtslashstar)) {
                return false;
            }
        }
        return true;
    }

    /**
     * Check if this token is a valid PostgreSQL-like command.
     * <p>
     * Migrated from TGSqlParser.isvalidsqlpluscmdInPostgresql().
     */
    private boolean isvalidsqlpluscmdInPostgresql(String str) {
        if (str == null) return false;
        if (str.length() == 0) return false;

        String s = str.trim().toLowerCase();
        return s.startsWith("\\");
    }

    // ========== Redshift-Specific Raw Statement Extraction ==========

    /**
     * Extract raw SQL statements from token list.
     * <p>
     * Migrated from TGSqlParser.doredshiftgetrawsqlstatements().
     * <p>
     * This method handles Redshift-specific statement boundaries:
     * <ul>
     *   <li>Semicolon (;) for regular SQL statements</li>
     *   <li>Function delimiter ($$) for function bodies</li>
     *   <li>BEGIN/END blocks for PL/pgSQL</li>
     *   <li>DECLARE blocks</li>
     * </ul>
     */
    private void doredshiftgetrawsqlstatements(SqlParseResult.Builder builder) {
        int waitingEnd = 0;
        boolean foundEnd = false, enterDeclare = false;

        if (TBaseType.assigned(sqlstatements)) sqlstatements.clear();
        if (!TBaseType.assigned(sourcetokenlist)) {
            builder.errorCode(-1);
            return;
        }

        gcurrentsqlstatement = null;
        EFindSqlStateType gst = EFindSqlStateType.stnormal;
        TSourceToken lcprevsolidtoken = null, ast = null;

        if (parserContext.isSinglePLBlock()) {
            gcurrentsqlstatement = new TCommonBlock(EDbVendor.dbvpostgresql);
        }

        // Mantis 4497: a '/' on its own line is tentatively flagged as an Oracle
        // SQL*Plus statement terminator (tokencode sqlpluscmd, but tokentype still
        // ttslash) by doredshiftsqltexttotokenlist(). Redshift has no '/' terminator
        // -- '/' is the division operator. When such a slash sits between two
        // operands (its next solid token can start a right-hand operand), revert it
        // to a normal division operator so the surrounding expression is parsed as a
        // single statement instead of being split. A genuine terminator is followed
        // by end-of-input or a statement keyword, never a bare operand, so it keeps
        // the sqlpluscmd flag and still splits. This pre-pass runs before the main
        // extraction loop because sqlplusaftercurtoken() peeks ahead at the slash
        // while processing the preceding token, so the revert must already be done.
        for (int i = 0; i < sourcetokenlist.size(); i++) {
            TSourceToken st = sourcetokenlist.get(i);
            if ((st.tokencode == TBaseType.sqlpluscmd)
                    && (st.tokentype == ETokenType.ttslash)
                    && isDivisionOperatorContext(st)) {
                st.tokencode = (int) '/';
            }
        }

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

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

            // Redshift-specific token adjustments
            if (ast.tokencode == TBaseType.rrw_redshift_filter) {
                TSourceToken st1 = ast.nextSolidToken();
                if (st1 != null) {
                    if (st1.tokencode != '(') {
                        ast.tokencode = TBaseType.ident;
                    }
                }
            } else if (ast.tokencode == TBaseType.rrw_redshift_array) {
                TSourceToken st1 = ast.searchToken('<', 1);
                if (st1 != null) { // array<varchar(20)>
                    ast.tokencode = TBaseType.rrw_redshift_array_type;
                }
            } else if (ast.tokencode == TBaseType.rrw_redshift_prior) {
                // PRIOR is a valid identifier/alias in Redshift. When followed by '.',
                // it can only start a qualified column reference (prior.column_a) —
                // never the CONNECT BY unary operator (PRIOR expr) or the FETCH
                // direction (PRIOR FROM), and a float literal like .5 lexes as a
                // single numeric token, not a bare '.'.
                TSourceToken st1 = ast.nextSolidToken();
                if ((st1 != null) && (st1.tokencode == '.')) {
                    ast.tokencode = TBaseType.ident;
                }
            } else if (ast.tokencode == TBaseType.rrw_binary) {
                // Distinguish BINARY as data type from BINARY as identifier
                // BINARY is a type when:
                // - Preceded by: AS (CAST), comma, left paren, column name
                // - Followed by: VARYING, left paren, comma, right paren, NOT, NULL
                TSourceToken prevToken = ast.prevSolidToken();
                TSourceToken nextToken = ast.nextSolidToken();

                // Check if preceded by a period -> identifier (e.g., table.binary)
                if (prevToken != null && prevToken.tokencode == '.') {
                    // Keep as identifier, no change
                }
                // Check type contexts by previous token
                else if (prevToken != null &&
                        (prevToken.tokencode == TBaseType.rrw_as ||           // CAST(x AS BINARY)
                         prevToken.tokencode == ',' ||                         // func(INT, BINARY)
                         prevToken.tokencode == '(' ||                         // (col BINARY), CAST(BINARY ...
                         prevToken.tokentype == ETokenType.ttidentifier)) {    // column_name BINARY
                    ast.tokencode = TBaseType.rrw_redshift_binary_as_type;
                }
                // Check type contexts by next token
                else if (nextToken != null &&
                        (nextToken.tokencode == TBaseType.rrw_varying ||       // BINARY VARYING
                         nextToken.tokencode == '(' ||                          // BINARY(10)
                         nextToken.tokencode == ',' ||                          // col BINARY, col2
                         nextToken.tokencode == ')' ||                          // col BINARY)
                         nextToken.tokencode == TBaseType.rrw_not ||           // BINARY NOT NULL
                         nextToken.tokencode == TBaseType.rrw_null)) {         // BINARY NULL
                    ast.tokencode = TBaseType.rrw_redshift_binary_as_type;
                }
            } else if (ast.tokencode == TBaseType.rrw_values) {
                TSourceToken stParen = ast.searchToken('(', 1);
                if (stParen != null) {
                    TSourceToken stInsert = ast.searchToken(TBaseType.rrw_insert, -ast.posinlist);
                    if (stInsert != null) {
                        TSourceToken stSemiColon = ast.searchToken(';', -ast.posinlist);
                        if ((stSemiColon != null) && (stSemiColon.posinlist > stInsert.posinlist)) {
                            // INSERT INTO test values (16,1), (8,2), (4,4), (2,0), (97, 16);
                            // VALUES (1);
                            // don't treat values(1) as insert values
                        } else {
                            TSourceToken stFrom = ast.searchToken(TBaseType.rrw_from, -ast.posinlist);
                            if ((stFrom != null) && (stFrom.posinlist > stInsert.posinlist)) {
                                // don't treat values after from keyword as an insert values
                                // insert into inserttest values(10, 20, '40'), (-1, 2, DEFAULT),
                                // ((select 2), (select i from (values(3) ) as foo (i)), 'values are fun!');
                            } else {
                                ast.tokencode = TBaseType.rrw_postgresql_insert_values;
                            }
                        }
                    }
                }
            }

            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;
                } //sterror

                case stnormal: {
                    if ((ast.tokencode == TBaseType.cmtdoublehyphen)
                            || (ast.tokencode == TBaseType.cmtslashstar)
                            || (ast.tokencode == TBaseType.lexspace)
                            || (ast.tokencode == TBaseType.lexnewline)
                            || (ast.tokentype == ETokenType.ttsemicolon)) {
                        if (gcurrentsqlstatement != null) {
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                        }

                        if ((lcprevsolidtoken != null) && (ast.tokentype == ETokenType.ttsemicolon)) {
                            if (lcprevsolidtoken.tokentype == ETokenType.ttsemicolon) {
                                // ;;;; continuous semicolon, treat it as comment
                                ast.tokentype = ETokenType.ttsimplecomment;
                                ast.tokencode = TBaseType.cmtdoublehyphen;
                            }
                        }

                        continue;
                    }

                    if (ast.tokencode == TBaseType.sqlpluscmd) {
                        gst = EFindSqlStateType.stsqlplus;
                        gcurrentsqlstatement = new TSqlplusCmdStatement(vendor);
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        continue;
                    }

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

                    if (gcurrentsqlstatement != null) {
                        enterDeclare = false;
                        if (gcurrentsqlstatement.ispgplsql()) {
                            gst = EFindSqlStateType.ststoredprocedure;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            foundEnd = false;
                            if ((ast.tokencode == TBaseType.rrw_begin)
                                    || (ast.tokencode == TBaseType.rrw_package)
                                    || (ast.searchToken(TBaseType.rrw_package, 4) != null)) {
                                waitingEnd = 1;
                            } else if (ast.tokencode == TBaseType.rrw_declare) {
                                enterDeclare = true;
                            }
                        } else {
                            gst = EFindSqlStateType.stsql;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                        }
                    } else {
                        //error token found
                        this.syntaxErrors.add(new TSyntaxError(ast.getAstext(), ast.lineNo, (ast.columnNo < 0 ? 0 : ast.columnNo),
                                "Error when tokenize", 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;
                } // stnormal

                case stsqlplus: {
                    if (ast.insqlpluscmd) {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                    } else {
                        gst = EFindSqlStateType.stnormal; //this token must be newline,
                        gcurrentsqlstatement.sourcetokenlist.add(ast); // so add it here
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                    }

                    break;
                }//case stsqlplus

                case stsql: {
                    if (ast.tokentype == ETokenType.ttsemicolon) {
                        gst = EFindSqlStateType.stnormal;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        gcurrentsqlstatement.semicolonended = ast;
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        continue;
                    }

                    if (sourcetokenlist.sqlplusaftercurtoken()) { //most probably is / cmd
                        gst = EFindSqlStateType.stnormal;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        continue;
                    }

                    if (ast.tokencode == TBaseType.cmtdoublehyphen) {
                        if (ast.toString().trim().endsWith(TBaseType.sqlflow_stmt_delimiter_str)) { // -- sqlflow-delimiter
                            gst = EFindSqlStateType.stnormal;
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            continue;
                        }
                    }

                    // Check if a DDL keyword starts a new SQL statement without semicolon separator.
                    // Guard against false positives:
                    // - GRANT/REVOKE use CREATE/ALTER/DROP as privilege names
                    // - EXPLAIN statement can contain CREATE/ALTER/DROP (e.g. EXPLAIN CREATE TABLE)
                    // - CREATE OR ALTER pattern: ALTER follows OR inside a CREATE statement
                    if (ast.tokencode == TBaseType.rrw_create
                            || ast.tokencode == TBaseType.rrw_alter
                            || ast.tokencode == TBaseType.rrw_drop) {
                        boolean shouldCheckSplit = true;

                        // Don't split inside GRANT/REVOKE (CREATE/ALTER/DROP are privilege names)
                        if (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstoraclegrant
                                || gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstoraclerevoke
                                || gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstGrant
                                || gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstRevoke) {
                            shouldCheckSplit = false;
                        }

                        // Don't split inside EXPLAIN (EXPLAIN CREATE TABLE, EXPLAIN ALTER, etc.)
                        if (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstExplain) {
                            shouldCheckSplit = false;
                        }

                        // Don't split ALTER/DROP when preceded by OR (CREATE OR ALTER pattern)
                        if (shouldCheckSplit && (ast.tokencode == TBaseType.rrw_alter || ast.tokencode == TBaseType.rrw_drop)) {
                            TSourceToken prevSolid = ast.prevSolidToken();
                            if (prevSolid != null && prevSolid.tokencode == TBaseType.rrw_or) {
                                shouldCheckSplit = false;
                            }
                        }

                        if (shouldCheckSplit) {
                            TCustomSqlStatement lcnextsqlstmt = sqlcmds.issql(ast, gst, gcurrentsqlstatement);
                            if (lcnextsqlstmt != null) {
                                // Finalize current statement and start the new one
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                                gcurrentsqlstatement = lcnextsqlstmt;
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                if (gcurrentsqlstatement.ispgplsql()) {
                                    gst = EFindSqlStateType.ststoredprocedure;
                                }
                                // else stay in stsql
                                continue;
                            }
                        }
                    }

                    gcurrentsqlstatement.sourcetokenlist.add(ast);
                    break;
                }//case stsql

                case ststoredprocedure: {
                    if (ast.tokencode == TBaseType.rrw_redshift_function_delimiter) {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        gst = EFindSqlStateType.ststoredprocedurePgStartBody;
                        continue;
                    }

                    if (ast.tokencode == TBaseType.rrw_redshift_language) {
                        // check next token which is the language used by this stored procedure
                        TSourceToken nextSt = ast.nextSolidToken();
                        if (nextSt != null) {
                            if (gcurrentsqlstatement instanceof TRoutine) {  // can be TCreateProcedureStmt or TCreateFunctionStmt
                                TRoutine p = (TRoutine) gcurrentsqlstatement;
                                p.setRoutineLanguage(nextSt.toString());
                            }
                        }
                    }

                    if ((ast.tokentype == ETokenType.ttsemicolon) && (waitingEnd == 0) && (!enterDeclare)) {
                        gst = EFindSqlStateType.stnormal;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        gcurrentsqlstatement.semicolonended = ast;
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        continue;
                    }

                    if ((ast.tokencode == TBaseType.rrw_begin)) {
                        waitingEnd++;
                        enterDeclare = false;
                    } else if ((ast.tokencode == TBaseType.rrw_declare)) {
                        enterDeclare = true;
                    } else if ((ast.tokencode == TBaseType.rrw_if)) {
                        if (ast.searchToken(TBaseType.rrw_end, -1) == null) {
                            //this is not if after END
                            waitingEnd++;
                        }
                    } else if ((ast.tokencode == TBaseType.rrw_case)) {
                        if (ast.searchToken(TBaseType.rrw_end, -1) == null) {
                            //this is not case after END
                            waitingEnd++;
                        }
                    } else if ((ast.tokencode == TBaseType.rrw_loop)) {
                        if (ast.searchToken(TBaseType.rrw_end, -1) == null) {
                            //this is not loop after END
                            waitingEnd++;
                        }
                    } else if (ast.tokencode == TBaseType.rrw_end) {
                        foundEnd = true;
                        waitingEnd--;
                        if (waitingEnd < 0) {
                            waitingEnd = 0;
                        }
                    }

                    if ((ast.tokentype == ETokenType.ttslash) && (ast.tokencode == TBaseType.sqlpluscmd)) {
                        // TPlsqlStatementParse(asqlstatement).TerminatorToken := ast;
                        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.tokentype == ETokenType.ttperiod) && (sourcetokenlist.returnaftercurtoken(false)) && (sourcetokenlist.returnbeforecurtoken(false))) {
                        // single dot at a separate line
                        ast.tokenstatus = ETokenStatus.tsignorebyyacc;
                        gst = EFindSqlStateType.stnormal;
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);

                        //make ttperiod a sqlplus cmd
                        gcurrentsqlstatement = new TSqlplusCmdStatement(vendor);
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                    } else {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        if ((ast.tokentype == ETokenType.ttsemicolon) && (waitingEnd == 0)
                                && (foundEnd)) {
                            gst = EFindSqlStateType.stnormal;
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        }
                    }

                    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 {
                            ast.tokencode = TBaseType.ident;
                        }
                    }

                    if ((gst == EFindSqlStateType.ststoredprocedure) && (ast.tokencode == TBaseType.cmtdoublehyphen)) {
                        if (ast.toString().trim().endsWith(TBaseType.sqlflow_stmt_delimiter_str)) { // -- sqlflow-delimiter
                            gst = EFindSqlStateType.stnormal;
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        }
                    }

                    break;
                } //ststoredprocedure

                case ststoredprocedurePgStartBody: {
                    // Check if this is the closing delimiter
                    if (ast.tokencode == TBaseType.rrw_redshift_function_delimiter) {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        gst = EFindSqlStateType.ststoredprocedurePgEndBody;
                        continue;
                    }

                    // Only add function body tokens if language is SQL or PLPGSQL
                    // For other languages (e.g., plpythonu, plperl), skip tokens so the
                    // parser sees two consecutive delimiters and matches the empty body rule
                    boolean shouldAddToken = true; // Default: add tokens (assume SQL/PLPGSQL)

                    // Look ahead to find the LANGUAGE keyword after the closing $$
                    // to determine if we should skip these tokens
                    TSourceToken languageToken = null;
                    for (int j = i + 1; j < sourcetokenlist.size(); j++) {
                        TSourceToken lookahead = sourcetokenlist.get(j);
                        if (lookahead.tokencode == TBaseType.rrw_redshift_function_delimiter) {
                            // Found closing delimiter, now look for LANGUAGE keyword
                            for (int k = j + 1; k < sourcetokenlist.size(); k++) {
                                TSourceToken st = sourcetokenlist.get(k);
                                if (st.tokencode == TBaseType.rrw_redshift_language) {
                                    // Found LANGUAGE, check next solid token for the language name
                                    languageToken = st.nextSolidToken();
                                    break;
                                }
                                if (st.tokentype == ETokenType.ttsemicolon) {
                                    break; // Reached end of statement
                                }
                            }
                            break;
                        }
                    }

                    if (languageToken != null) {
                        String language = languageToken.toString().toLowerCase().trim();
                        // Remove quotes if present
                        if (language.startsWith("'") && language.endsWith("'")) {
                            language = language.substring(1, language.length() - 1);
                        }
                        // Skip tokens for non-SQL/non-PLPGSQL languages
                        if (!language.equals("sql") && !language.equals("plpgsql")) {
                            shouldAddToken = false;
                        }
                    }

                    if (shouldAddToken) {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                    }

                    break;
                }

                case ststoredprocedurePgEndBody: {
                    if (ast.tokentype == ETokenType.ttsemicolon) {
                        gst = EFindSqlStateType.stnormal;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        gcurrentsqlstatement.semicolonended = ast;
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        continue;
                    } else if (ast.tokencode == TBaseType.cmtdoublehyphen) {
                        if (ast.toString().trim().endsWith(TBaseType.sqlflow_stmt_delimiter_str)) { // -- sqlflow-delimiter
                            gst = EFindSqlStateType.stnormal;
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            continue;
                        }
                    }

                    gcurrentsqlstatement.sourcetokenlist.add(ast);

                    if (ast.tokencode == TBaseType.rrw_redshift_language) {
                        // check next token which is the language used by this stored procedure
                        TSourceToken nextSt = ast.nextSolidToken();
                        if (nextSt != null) {
                            if (gcurrentsqlstatement instanceof TRoutine) {  // can be TCreateProcedureStmt or TCreateFunctionStmt
                                TRoutine p = (TRoutine) gcurrentsqlstatement;
                                p.setRoutineLanguage(nextSt.toString());
                            }
                        }
                    }

                    break;
                }
            } //switch
        }//for

        //last statement
        if ((gcurrentsqlstatement != null) &&
                ((gst == EFindSqlStateType.stsqlplus) || (gst == EFindSqlStateType.stsql)
                        || (gst == EFindSqlStateType.ststoredprocedure)
                        || (gst == EFindSqlStateType.ststoredprocedurePgEndBody)
                        || (gst == EFindSqlStateType.sterror) || (parserContext.isSinglePLBlock()))) {
            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, true, builder);
        }

        builder.errorCode(syntaxErrors.size());
    }

    /**
     * Handle CREATE TABLE error recovery.
     * <p>
     * Migrated from TGSqlParser.handleCreateTableErrorRecovery().
     */
    private void handleCreateTableErrorRecovery(TCustomSqlStatement stmt) {
        if (((stmt.sqlstatementtype == ESqlStatementType.sstcreatetable)
                || (stmt.sqlstatementtype == ESqlStatementType.sstcreateindex))
                && (!TBaseType.c_createTableStrictParsing)) {

            int nested = 0;
            boolean isIgnore = false, isFoundIgnoreToken = false;
            TSourceToken firstIgnoreToken = null;

            for (int k = 0; k < stmt.sourcetokenlist.size(); k++) {
                TSourceToken st = stmt.sourcetokenlist.get(k);
                if (isIgnore) {
                    if (st.issolidtoken() && (st.tokencode != ';')) {
                        isFoundIgnoreToken = true;
                        if (firstIgnoreToken == null) {
                            firstIgnoreToken = st;
                        }
                    }
                    if (st.tokencode != ';') {
                        st.tokencode = TBaseType.sqlpluscmd;
                    }
                    continue;
                }
                if (st.tokencode == (int) ')') {
                    nested--;
                    if (nested == 0) {
                        boolean isSelect = false;
                        TSourceToken st1 = st.searchToken(TBaseType.rrw_as, 1);
                        if (st1 != null) {
                            TSourceToken st2 = st.searchToken((int) '(', 2);
                            if (st2 != null) {
                                TSourceToken st3 = st.searchToken(TBaseType.rrw_select, 3);
                                isSelect = (st3 != null);
                            }
                        }
                        if (!isSelect) isIgnore = true;
                    }
                } else if (st.tokencode == (int) '(') {
                    nested++;
                }
            }

            if (isFoundIgnoreToken) {
                stmt.clearError();
                stmt.parsestatement(null, false);
            }
        }
    }

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