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.TLexerOceanbasemysql;
import gudusoft.gsqlparser.TParserOceanbasemysql;
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.oracle.TSqlplusCmdStatement;
import gudusoft.gsqlparser.stmt.TUnknownSqlStatement;
import gudusoft.gsqlparser.sqlcmds.ISqlCmds;
import gudusoft.gsqlparser.sqlcmds.SqlCmdsFactory;
import gudusoft.gsqlparser.stmt.mysql.TMySQLSource;
import gudusoft.gsqlparser.compiler.TContext;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.compiler.TGlobalScope;
import gudusoft.gsqlparser.compiler.TFrame;

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

/**
 * OceanBase user tenant — MySQL compatibility mode parser (Phase 2 fork).
 *
 * <p>This class is a verbatim fork of {@link MySqlSqlParser} with class
 * names rewritten to point at the forked grammar artifacts under
 * {@code gsp_java_parser/.../parser/oceanbasemysql/}. The structural
 * intent is identical to the MySQL parser; what differs is:
 *
 * <ul>
 *   <li>It uses {@link TLexerOceanbasemysql} and
 *       {@link TParserOceanbasemysql} (generated from the forked
 *       {@code lzlexoceanbasemysql.l} / {@code lzyaccoceanbasemysql.y}
 *       sources by {@code parsetable}'s generic-vendor fallback path).</li>
 *   <li>It registers as {@link EDbVendor#dbvoceanbase} so downstream
 *       components (sqlcmds, IdentifierProfile, the various TSQLEnv
 *       EnumMaps) consult OceanBase rules rather than MySQL rules.</li>
 *   <li>It is selected by {@link OceanBaseSqlParser} when the active
 *       {@link gudusoft.gsqlparser.EOBTenantMode} is
 *       {@link gudusoft.gsqlparser.EOBTenantMode#MYSQL} or
 *       {@link gudusoft.gsqlparser.EOBTenantMode#SYSTEM}.</li>
 * </ul>
 *
 * <p>Phase 2 ships this fork at zero divergence from the MySQL base
 * grammar — same shift/reduce conflicts, same token positions, same
 * statement coverage. OceanBase-specific extensions (hints, partition
 * extensions, tenant DDL, outlines, tablegroups) arrive incrementally
 * in Phase 4 via additive edits to the {@code .y} source. Each Phase 4
 * addition is tracked in {@code oceanbasemysql/FORK_DIVERGENCE.md}.
 *
 * <p>Backporting upstream MySQL grammar fixes is documented in the
 * Phase 0 plan ({@code gsp_java_core/doc/oceanbase/PHASE0_REPORT.md})
 * and the per-fork {@code oceanbasemysql/REGEN.md}.
 *
 * @see MySqlSqlParser the unmodified base parser this class was forked from
 * @see OceanBaseSqlParser the mode-routing adapter that selects this parser
 * @see TLexerOceanbasemysql forked lexer
 * @see TParserOceanbasemysql forked parser
 * @since 4.0.1.4
 */
public class OceanBaseMysqlSqlParser extends AbstractSqlParser {

    // ========== Lexer and Parser Instances ==========
    // Created once in constructor, reused for all parsing operations

    /** The MySQL lexer used for tokenization (public for TGSqlParser.getFlexer()) */
    public TLexerOceanbasemysql flexer;
    private TParserOceanbasemysql fparser;

    // ========== State Variables ==========
    // NOTE: The following fields moved to AbstractSqlParser (inherited):
    //   - sourcetokenlist (TSourceTokenList)
    //   - sqlstatements (TStatementList)
    //   - parserContext (ParserContext)
    //   - sqlcmds (ISqlCmds)
    //   - globalContext (TContext)
    //   - sqlEnv (TSQLEnv)
    //   - frameStack (Stack<TFrame>)
    //   - globalFrame (TFrame)
    //   - lexer (TCustomLexer)

    // ========== State Variables for Raw Statement Extraction ==========
    private String userDelimiterStr;
    private char curdelimiterchar;
    private boolean waitingDelimiter;

    // ========== Constructor ==========

    /**
     * Construct MySQL SQL parser.
     * <p>
     * Configures the parser for MySQL database with default delimiter: semicolon (;)
     * <p>
     * Following the original TGSqlParser pattern, the lexer and parser are
     * created once in the constructor and reused for all parsing operations.
     */
    public OceanBaseMysqlSqlParser() {
        // Phase 2 fork: register as dbvoceanbase even though the lexer/parser
        // are forked from MySQL. AST nodes built via this parser report
        // dbvoceanbase via the NodeFactory back-reference fixup in
        // TGSqlParser.doDelegatedRawParse(); the vendor passed here is the
        // one consulted by sqlcmds, IdentifierProfile, and the various
        // EnumMaps in TSQLEnv.
        super(EDbVendor.dbvoceanbase);

        // Set delimiter character
        this.delimiterChar = '$';
        this.defaultDelimiterStr = "$";

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

        // CRITICAL: Set lexer for inherited getanewsourcetoken() method
        this.lexer = this.flexer;

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

        // NOTE: sourcetokenlist and sqlstatements are initialized in AbstractSqlParser constructor
    }

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

    /**
     * Return the MySQL lexer instance.
     * <p>
     * The lexer is created once in the constructor and reused for all
     * parsing operations. This method simply returns the existing instance,
     * matching the original TGSqlParser pattern where the lexer is created
     * once and reset before each use.
     *
     * @param context parser context (not used, lexer already created)
     * @return the MySQL lexer instance created in constructor
     */
    @Override
    protected TCustomLexer getLexer(ParserContext context) {
        // Return existing lexer instance (created in constructor)
        return this.flexer;
    }

    /**
     * Return the MySQL SQL parser instance with updated token list.
     * <p>
     * The parser is created once in the constructor and reused for all
     * parsing operations. This method updates the token list and returns
     * the existing instance, matching the original TGSqlParser pattern.
     *
     * @param context parser context (not used, parser already created)
     * @param tokens source token list to parse
     * @return the MySQL SQL parser instance created in constructor
     */
    @Override
    protected TCustomParser getParser(ParserContext context, TSourceTokenList tokens) {
        // Update token list for reused parser instance
        this.fparser.sourcetokenlist = tokens;
        return this.fparser;
    }

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

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

    /**
     * Call MySQL-specific raw statement extraction logic.
     * <p>
     * Delegates to domysqlgetrawsqlstatements which handles MySQL's
     * statement delimiters (semicolon by default, or custom delimiter via DELIMITER command).
     */
    @Override
    protected void extractVendorRawStatements(SqlParseResult.Builder builder) {
        domysqlgetrawsqlstatements(builder);
    }

    /**
     * Perform full parsing of statements with syntax checking.
     * <p>
     * This method orchestrates the parsing of all statements.
     *
     * <p><b>Important:</b> This method does NOT extract raw statements - they are
     * passed in as a parameter already extracted by {@link #extractRawStatements}.
     *
     * @param context parser context
     * @param parser main SQL parser (TParserOceanbasemysql)
     * @param secondaryParser not used for MySQL
     * @param tokens source token list
     * @param rawStatements raw statements already extracted (never null)
     * @return list of fully parsed statements with AST built
     */
    @Override
    protected TStatementList performParsing(ParserContext context,
                                           TCustomParser parser,
                                           TCustomParser secondaryParser,
                                           TSourceTokenList tokens,
                                           TStatementList rawStatements) {
        // Store references (fparser is already set, don't reassign final variable)
        this.sourcetokenlist = tokens;
        this.parserContext = context;

        // Use the raw statements passed from AbstractSqlParser.parse()
        // (already extracted - DO NOT re-extract to avoid duplication)
        this.sqlstatements = rawStatements;

        // Initialize sqlcmds for the parser
        this.sqlcmds = SqlCmdsFactory.get(vendor);
        this.fparser.sqlcmds = this.sqlcmds;

        // Initialize global context for statement parsing
        initializeGlobalContext();

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

            try {
                // Set frame stack for the statement (needed for parsing)
                stmt.setFrameStack(frameStack);

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

                // Handle error recovery for CREATE TABLE statements if enabled
                boolean doRecover = TBaseType.ENABLE_ERROR_RECOVER_IN_CREATE_TABLE;
                if (doRecover && ((parseResult != 0) || (stmt.getErrorCount() > 0))) {
                    handleCreateTableErrorRecovery(stmt);
                }

                // Collect syntax 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 this.sqlstatements;
    }

    /**
     * Handle error recovery for CREATE TABLE statements.
     * <p>
     * Migrated from TGSqlParser.handleCreateTableErrorRecovery()
     * <p>
     * This method marks unparseable table properties as sqlpluscmd tokens
     * and retries parsing, similar to MSSQL error recovery.
     *
     * @param stmt the statement that failed to parse
     */
    private void handleCreateTableErrorRecovery(TCustomSqlStatement stmt) {
        if ((stmt.sqlstatementtype != ESqlStatementType.sstcreatetable) || TBaseType.c_createTableStrictParsing) {
            return;
        }

        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, this.parserContext.isOnlyNeedRawParseTree());
        }
    }

    // ========== MySQL-Specific Tokenization ==========

    /**
     * Perform MySQL-specific tokenization.
     * <p>
     * Extracted from TGSqlParser.domysqltexttotokenlist() (lines 4759-4822)
     */
    private void domysqltexttotokenlist() {
        TSourceToken asourcetoken, lcprevst;
        int yychar;
        boolean startDelimiter = false;

        flexer.tmpDelimiter = "";

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

        if ((asourcetoken.tokencode == TBaseType.rrw_mysql_delimiter)) {
            startDelimiter = true;
        }

        while (yychar > 0) {
            sourcetokenlist.add(asourcetoken);
            asourcetoken = getanewsourcetoken();
            if (asourcetoken == null) break;
            checkMySQLCommentToken(asourcetoken);

            if ((asourcetoken.tokencode == TBaseType.lexnewline) && (startDelimiter)) {
                startDelimiter = false;
                flexer.tmpDelimiter = sourcetokenlist.get(sourcetokenlist.size() - 1).getAstext();
            }

            if ((asourcetoken.tokencode == TBaseType.rrw_mysql_delimiter)) {
                startDelimiter = true;
            }

            if (asourcetoken.tokencode == TBaseType.rrw_rollup) {
                // with rollup
                lcprevst = getprevsolidtoken(asourcetoken);
                if (lcprevst != null) {
                    if (lcprevst.tokencode == TBaseType.rrw_with)
                        lcprevst.tokencode = TBaseType.with_rollup;
                }
            }

            if ((asourcetoken.tokencode == TBaseType.rrw_mysql_d)
                    || (asourcetoken.tokencode == TBaseType.rrw_mysql_t)
                    || (asourcetoken.tokencode == TBaseType.rrw_mysql_ts)) {
                // odbc date constant { d 'str' }
                lcprevst = getprevsolidtoken(asourcetoken);
                if (lcprevst != null) {
                    if (lcprevst.tokencode != '{')
                        asourcetoken.tokencode = TBaseType.ident;
                }
            }

            yychar = asourcetoken.tokencode;
        }
    }

    /**
     * Check if MySQL comment token is valid.
     * <p>
     * MySQL requires a space after -- for double-hyphen comments.
     * This method was present in TGSqlParser but the implementation
     * was commented out, so we keep it as a placeholder.
     *
     * @param cmtToken comment token to check
     */
    private void checkMySQLCommentToken(TSourceToken cmtToken) {
        // Implementation was commented out in original TGSqlParser
        // Keeping this method as placeholder for future use
    }

    /**
     * Get previous non-whitespace token.
     *
     * @param ptoken current token
     * @return previous solid token, or null
     */
    private TSourceToken getprevsolidtoken(TSourceToken ptoken) {
        TSourceToken ret = null;
        TSourceTokenList lctokenlist = ptoken.container;

        if (lctokenlist != null) {
            if ((ptoken.posinlist > 0) && (lctokenlist.size() > ptoken.posinlist - 1)) {
                if (!(
                        (lctokenlist.get(ptoken.posinlist - 1).tokentype == ETokenType.ttwhitespace)
                        || (lctokenlist.get(ptoken.posinlist - 1).tokentype == ETokenType.ttreturn)
                        || (lctokenlist.get(ptoken.posinlist - 1).tokentype == ETokenType.ttsimplecomment)
                        || (lctokenlist.get(ptoken.posinlist - 1).tokentype == ETokenType.ttbracketedcomment)
                )) {
                    ret = lctokenlist.get(ptoken.posinlist - 1);
                } else {
                    ret = lctokenlist.nextsolidtoken(ptoken.posinlist - 1, -1, false);
                }
            }
        }
        return ret;
    }

    // ========== MySQL-Specific Raw Statement Extraction ==========

    /**
     * Extract raw MySQL SQL statements from tokenized source.
     * <p>
     * Extracted from TGSqlParser.domysqlgetrawsqlstatements() (lines 14979-15344)
     *
     * @param builder the result builder to populate with raw statements
     */
    private void domysqlgetrawsqlstatements(SqlParseResult.Builder builder) {
        TCustomSqlStatement gcurrentsqlstatement = null;
        EFindSqlStateType gst = EFindSqlStateType.stnormal;

        // Reset delimiter
        userDelimiterStr = defaultDelimiterStr;

        if (TBaseType.assigned(sqlstatements)) sqlstatements.clear();
        if (!TBaseType.assigned(sourcetokenlist)) {
            // No tokens available - populate builder with empty results and return
            builder.sqlStatements(this.sqlstatements);
            builder.errorCode(1);
            builder.errorMessage("No source token list available");
            return;
        }

        for (int i = 0; i < sourcetokenlist.size(); i++) {
            TSourceToken ast = sourcetokenlist.get(i);
            sourcetokenlist.curpos = i;

            // Token transformations during raw statement extraction
            performRawStatementTokenTransformations(ast);

            switch (gst) {
                case sterror: {
                    if (ast.tokentype == ETokenType.ttsemicolon) {
                        appendToken(gcurrentsqlstatement, ast);
                        onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                        gcurrentsqlstatement = null;
                        gst = EFindSqlStateType.stnormal;
                    } else {
                        appendToken(gcurrentsqlstatement, 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)) {
                            appendToken(gcurrentsqlstatement, ast);
                        }
                        continue;
                    }

                    if (ast.isFirstTokenOfLine() && (ast.toString().equalsIgnoreCase(userDelimiterStr))) {
                        ast.tokencode = ';';// treat it as semicolon
                        continue;
                    }

                    if ((ast.isFirstTokenOfLine()) && ((ast.tokencode == TBaseType.rrw_mysql_source) || (ast.tokencode == TBaseType.slash_dot))) {
                        gst = EFindSqlStateType.stsqlplus;
                        gcurrentsqlstatement = new TMySQLSource(vendor);
                        appendToken(gcurrentsqlstatement, ast);
                        continue;
                    }

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

                    if (TBaseType.assigned(gcurrentsqlstatement)) {
                        ESqlStatementType[] ses = {ESqlStatementType.sstmysqlcreateprocedure, ESqlStatementType.sstmysqlcreatefunction,
                                ESqlStatementType.sstcreateprocedure, ESqlStatementType.sstcreatefunction,
                                ESqlStatementType.sstcreatetrigger, ESqlStatementType.sstmysqlcreateevent,
                                ESqlStatementType.sstmysqlalterevent};
                        if (includesqlstatementtype(gcurrentsqlstatement.sqlstatementtype, ses)) {
                            gst = EFindSqlStateType.ststoredprocedure;
                            waitingDelimiter = false;
                            appendToken(gcurrentsqlstatement, ast);
                            curdelimiterchar = ';';
                            // Only initialize userDelimiterStr if not already set by DELIMITER statement
                            if (userDelimiterStr == null || userDelimiterStr.isEmpty()) {
                                userDelimiterStr = ";";
                            }
                        } else {
                            gst = EFindSqlStateType.stsql;
                            appendToken(gcurrentsqlstatement, 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 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;
                        appendToken(gcurrentsqlstatement, ast);
                    }
                    break;
                }

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

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

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

                    appendToken(gcurrentsqlstatement, 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)
                                    || (st.tokencode == TBaseType.rrw_set)) // set delimiter //
                            {
                                continue;
                            }

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

                    break;
                }

                case ststoredprocedure: {

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

                    // Handle waitingDelimiter logic (when inside BEGIN...END block)
                    // Skip this check if delimiter is ";" since we need to check for END; pattern instead
                    if (waitingDelimiter && !userDelimiterStr.equals(";")) {
                        if (userDelimiterStr.equalsIgnoreCase(ast.toString())) {
                            gst = EFindSqlStateType.stnormal;
                            gcurrentsqlstatement.semicolonended = ast;
                            onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                            gcurrentsqlstatement = null;
                            continue;
                        } else if (userDelimiterStr.startsWith(ast.toString())) {
                            String lcstr = ast.toString();
                            for (int k = ast.posinlist + 1; k < ast.container.size(); k++) {
                                TSourceToken st = ast.container.get(k);
                                if ((st.tokencode == TBaseType.rrw_mysql_delimiter) || (st.tokencode == TBaseType.lexnewline) || (st.tokencode == TBaseType.lexspace)) {
                                    break;
                                }
                                lcstr = lcstr + st.toString();
                            }

                            if (userDelimiterStr.equalsIgnoreCase(lcstr)) {
                                int lastDelimiterPos = ast.posinlist;
                                for (int k = ast.posinlist; k < ast.container.size(); k++) {
                                    TSourceToken st = ast.container.get(k);
                                    if ((st.tokencode == TBaseType.rrw_mysql_delimiter) || (st.tokencode == TBaseType.lexnewline) || (st.tokencode == TBaseType.lexspace)) {
                                        break;
                                    }
                                    st.tokenstatus = ETokenStatus.tsignorebyyacc;
                                    lastDelimiterPos = k;
                                }
                                gst = EFindSqlStateType.stnormal;
                                gcurrentsqlstatement.semicolonended = ast;
                                onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                                gcurrentsqlstatement = null;
                                i = lastDelimiterPos; // advance past all delimiter tokens
                                continue;
                            }
                        }
                    }

                    // Set waitingDelimiter when BEGIN is encountered
                    if (ast.tokencode == TBaseType.rrw_begin) {
                        waitingDelimiter = true;
                    }

                    // Main delimiter handling logic
                    // When not waiting for delimiter (no BEGIN block), complete at semicolon regardless of custom delimiter
                    if (!waitingDelimiter) {
                        appendToken(gcurrentsqlstatement, ast);
                        if (ast.tokentype == ETokenType.ttsemicolon) {
                            gst = EFindSqlStateType.stnormal;
                            gcurrentsqlstatement.semicolonended = ast;
                            onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                            gcurrentsqlstatement = null;
                            continue;
                        }
                    } else {
                        // When waitingDelimiter is true AND delimiter is ";", only check for END; pattern
                        if (waitingDelimiter && userDelimiterStr.equals(";")) {
                            // Check for END; pattern
                            if ((ast.tokentype == ETokenType.ttsemicolon)) {
                                TSourceToken lcprevtoken = ast.container.nextsolidtoken(ast, -1, false);
                                if (lcprevtoken != null) {
                                    if (lcprevtoken.tokencode == TBaseType.rrw_end) {
                                        gst = EFindSqlStateType.stnormal;
                                        gcurrentsqlstatement.semicolonended = ast;
                                        appendToken(gcurrentsqlstatement, ast);
                                        onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                                        gcurrentsqlstatement = null;
                                        continue;
                                    }
                                }
                            }
                            appendToken(gcurrentsqlstatement, ast);
                        } else {
                            // Custom delimiter handling (non-semicolon delimiters)
                            if (ast.toString().equals(userDelimiterStr)) {
                                ast.tokenstatus = ETokenStatus.tsignorebyyacc;
                                appendToken(gcurrentsqlstatement, ast);
                                gst = EFindSqlStateType.stnormal;
                                onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                                gcurrentsqlstatement = null;
                            } else {
                                appendToken(gcurrentsqlstatement, ast);
                            }
                        }
                    }

                    /*
                    // OLD LOGIC - replaced by above
                    if (curdelimiterchar == ';') {
                        appendToken(gcurrentsqlstatement, ast);
                        if (ast.tokentype == ETokenType.ttsemicolon) {
                            gst = EFindSqlStateType.stnormal;
                            gcurrentsqlstatement.semicolonended = ast;
                            onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                            continue;
                        }
                    } else {
                        // Handle multi-character delimiters
                        char ch;
                        if (ast.getAstext().length() == 1) {
                            ch = ast.getAstext().charAt(0);
                        } else if ((ast.getAstext().length() > 1) && (ast.issolidtoken())) {
                            ch = ast.getAstext().charAt(ast.getAstext().length() - 1);
                        } else {
                            ch = ' ';
                        }

                        if (ch == curdelimiterchar) {
                            if (ast.getAstext().length() > 1) {
                                String lcstr = ast.getAstext().substring(0, ast.getAstext().length() - 1);
                                int c = flexer.getkeywordvalue(lcstr);
                                if (c > 0) {
                                    ast.tokencode = c;
                                }
                            } else {
                                // Mark single-character delimiter to be ignored by parser
                                ast.tokenstatus = ETokenStatus.tsignorebyyacc;
                                gcurrentsqlstatement.semicolonended = ast;
                            }
                            appendToken(gcurrentsqlstatement, ast);
                            gst = EFindSqlStateType.stnormal;
                            onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                        } else {
                            appendToken(gcurrentsqlstatement, ast);
                        }
                    }
                    */
                    break;
                }
            }
        }

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

        // Populate builder with results
        builder.sqlStatements(this.sqlstatements);
        builder.syntaxErrors(syntaxErrors instanceof ArrayList ?
                (ArrayList<TSyntaxError>) syntaxErrors : new ArrayList<>(syntaxErrors));
        builder.errorCode(syntaxErrors.isEmpty() ? 0 : syntaxErrors.size());
    }

    /**
     * Handle token transformations during raw statement extraction.
     *
     * @param ast current token being processed
     */
    private void performRawStatementTokenTransformations(TSourceToken ast) {
        if (ast.tokencode == TBaseType.rrw_date) {
            TSourceToken st1 = ast.nextSolidToken();
            if (st1 != null) {
                if (st1.tokencode == '(') {
                    ast.tokencode = TBaseType.rrw_mysql_date_function;
                } else if (st1.tokencode == TBaseType.sconst) {
                    ast.tokencode = TBaseType.rrw_mysql_date_const;
                }
            }
        } else if (ast.tokencode == TBaseType.rrw_time) {
            TSourceToken st1 = ast.nextSolidToken();
            if (st1 != null) {
                if (st1.tokencode == TBaseType.sconst) {
                    ast.tokencode = TBaseType.rrw_mysql_time_const;
                }
            }
        } else if (ast.tokencode == TBaseType.rrw_timestamp) {
            TSourceToken st1 = ast.nextSolidToken();
            if (st1 != null) {
                if (st1.tokencode == TBaseType.sconst) {
                    ast.tokencode = TBaseType.rrw_mysql_timestamp_constant;
                } else if (st1.tokencode == TBaseType.ident) {
                    if (st1.toString().startsWith("\"")) {
                        ast.tokencode = TBaseType.rrw_mysql_timestamp_constant;
                        st1.tokencode = TBaseType.sconst;
                    }
                }
            }
        } else if (ast.tokencode == TBaseType.rrw_mysql_position) {
            TSourceToken st1 = ast.nextSolidToken();
            if (st1 != null) {
                if (st1.tokencode != '(') {
                    ast.tokencode = TBaseType.ident; // change position keyword to identifier if not followed by ()
                }
            }
        } else if (ast.tokencode == TBaseType.rrw_mysql_row) {
            boolean isIdent = true;
            TSourceToken st1 = ast.nextSolidToken();
            if (st1 != null) {
                if (st1.tokencode == '(') {
                    isIdent = false;
                }
            }
            st1 = ast.prevSolidToken();
            if (st1 != null) {
                if ((st1.tokencode == TBaseType.rrw_mysql_each) || (st1.tokencode == TBaseType.rrw_mysql_current)) {
                    isIdent = false;
                }
            }
            if (isIdent) ast.tokencode = TBaseType.ident;
        } else if (ast.tokencode == TBaseType.rrw_interval) {
            TSourceToken leftParen = ast.searchToken('(', 1);
            if (leftParen != null) {
                int k = leftParen.posinlist + 1;
                int nested = 1;
                boolean commaToken = false;
                while (k < ast.container.size()) {
                    if (ast.container.get(k).tokencode == '(') {
                        nested++;
                    }
                    if (ast.container.get(k).tokencode == ')') {
                        nested--;
                        if (nested == 0) break;
                    }
                    if ((ast.container.get(k).tokencode == ',') && (nested == 1)) {
                        // only calculate the comma in the first level which is belong to interval
                        // don't count comma in the nested () like this: INTERVAL (SELECT IF(1=1,2,3))
                        commaToken = true;
                        break;
                    }
                    k++;
                }
                if (commaToken) {
                    ast.tokencode = TBaseType.rrw_mysql_interval_func;
                }
            }
        }
    }

    /**
     * Helper method to check if a statement type is in an array of types.
     *
     * @param type the type to check
     * @param types array of types to check against
     * @return true if type is in the array
     */
    private boolean includesqlstatementtype(ESqlStatementType type, ESqlStatementType[] types) {
        for (ESqlStatementType t : types) {
            if (type == t) return true;
        }
        return false;
    }

    private void appendToken(TCustomSqlStatement statement, TSourceToken token) {
        if (statement == null || token == null) {
            return;
        }
        token.stmt = statement;
        statement.sourcetokenlist.add(token);
    }

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