package gudusoft.gsqlparser.parser;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.EErrorType;
import gudusoft.gsqlparser.EFindSqlStateType;
import gudusoft.gsqlparser.ESqlStatementType;
import gudusoft.gsqlparser.ETokenStatus;
import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.TCustomLexer;
import gudusoft.gsqlparser.TCustomParser;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TLexerEdb;
import gudusoft.gsqlparser.TParserEdb;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSourceTokenList;
import gudusoft.gsqlparser.TStatementList;
import gudusoft.gsqlparser.TSyntaxError;
import gudusoft.gsqlparser.TLog;
import gudusoft.gsqlparser.compiler.TASTEvaluator;
import gudusoft.gsqlparser.compiler.TContext;
import gudusoft.gsqlparser.compiler.TFrame;
import gudusoft.gsqlparser.compiler.TGlobalScope;
import gudusoft.gsqlparser.resolver.TSQLResolver;
import gudusoft.gsqlparser.sqlcmds.ISqlCmds;
import gudusoft.gsqlparser.sqlcmds.SqlCmdsFactory;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.stmt.TCommonBlock;
import gudusoft.gsqlparser.stmt.TCreateTableSqlStatement;
import gudusoft.gsqlparser.stmt.TRoutine;
import gudusoft.gsqlparser.stmt.TUnknownSqlStatement;
import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreatePackage;
import gudusoft.gsqlparser.stmt.oracle.TSqlplusCmdStatement;

import java.util.Stack;

/**
 * Edb SQL parser implementation.
 *
 * <p>This parser handles Edb-specific SQL syntax including:
 * <ul>
 *   <li>PostgreSQL-based SQL syntax with Oracle compatibility</li>
 *   <li>Stored procedures and functions (Oracle-style and PostgreSQL-style)</li>
 *   <li>Package specifications and bodies</li>
 *   <li>SQL*Plus-like commands</li>
 *   <li>Dynamic delimiter support</li>
 * </ul>
 *
 * <p><b>Implementation Status:</b> MIGRATED
 * <ul>
 *   <li><b>Completed:</b> Migrated from TGSqlParser to AbstractSqlParser</li>
 *   <li><b>Current:</b> Fully self-contained Edb parser</li>
 * </ul>
 *
 * <p><b>Design Notes:</b>
 * <ul>
 *   <li>Extends {@link AbstractSqlParser} using template method pattern</li>
 *   <li>Uses single parser: {@link TParserEdb}</li>
 *   <li>Primary delimiter: semicolon (;)</li>
 *   <li>Supports both Oracle-style and PostgreSQL-style routines</li>
 *   <li>Handles package specifications and bodies with Edb-specific state tracking</li>
 * </ul>
 *
 * @see SqlParser
 * @see AbstractSqlParser
 * @see TLexerEdb
 * @see TParserEdb
 * @since 3.2.0.0
 */
public class EdbSqlParser extends AbstractSqlParser {

    // ========== Lexer and Parser ==========

    /** The Edb lexer used for tokenization */
    public TLexerEdb flexer;

    /** The Edb parser used for parsing */
    private TParserEdb fparser;

    // ========== Statement Extraction State ==========

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

    /** Flag to indicate if this is an Oracle-style routine */
    private boolean isOracleStyleRoutine = true;

    /** Procedure statement reference for tracking */
    private TSourceToken stProcedure = null;

    /** Function statement reference for tracking */
    private TSourceToken stFunction = null;

    /**
     * Construct Edb SQL parser.
     * <p>
     * Configures the parser for Edb database with semicolon (;) as the default delimiter.
     */
    public EdbSqlParser() {
        super(EDbVendor.dbvedb);
        this.delimiterChar = ';';
        this.defaultDelimiterStr = ";";

        // Create lexer once - will be reused for all parsing operations
        this.flexer = new TLexerEdb();
        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 TParserEdb(null);
        this.fparser.lexer = this.flexer;
    }

    // ========== Abstract Method Implementations ==========

    @Override
    protected TCustomLexer getLexer(ParserContext context) {
        return this.flexer;
    }

    @Override
    protected TCustomParser getParser(ParserContext context, TSourceTokenList tokens) {
        this.fparser.sourcetokenlist = tokens;
        return this.fparser;
    }

    @Override
    protected TCustomParser getSecondaryParser(ParserContext context, TSourceTokenList tokens) {
        // Edb does not have a secondary parser
        return null;
    }

    // ========== Phase 2: Tokenization (Hook Pattern) ==========

    @Override
    protected void tokenizeVendorSql() {
        doedbtexttotokenlist();
    }

    /**
     * Tokenize Edb SQL text into source tokens.
     * <p>
     * Migrated from TGSqlParser.doedbtexttotokenlist() (lines 2899-3026).
     * <p>
     * Handles:
     * <ul>
     *   <li>SQL*Plus-like command detection</li>
     *   <li>Forward slash disambiguation (division vs SQL*Plus command)</li>
     *   <li>PostgreSQL-style keyword handling (INNER, NOT DEFERRABLE, etc.)</li>
     * </ul>
     */
    private void doedbtexttotokenlist() {
        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;

                    // the inner keyword token should be converted to TBaseType.ident when
                    // next solid token is not join

                    if (prevst != null) {
                        if (prevst.tokencode == TBaseType.rrw_inner)//flexer.getkeywordvalue("INNER"))
                        {
                            if (asourcetoken.tokencode != flexer.getkeywordvalue("JOIN")) {
                                prevst.tokencode = TBaseType.ident;
                            }
                        }


                        if ((prevst.tokencode == TBaseType.rrw_not)
                                && (asourcetoken.tokencode == flexer.getkeywordvalue("DEFERRABLE"))) {
                            prevst.tokencode = flexer.getkeywordvalue("NOT_DEFERRABLE");
                            asourcetoken.tokenstatus = ETokenStatus.tsignorebyyacc;
                        }
                    }

                    if (asourcetoken.tokencode == TBaseType.rrw_inner) {
                        prevst = asourcetoken;
                    } else if (asourcetoken.tokencode == TBaseType.rrw_not) {
                        prevst = asourcetoken;
                    } else {
                        prevst = null;
                    }

                    if ((asourcetoken.tokencode == flexer.getkeywordvalue("DIRECT_LOAD"))
                            || (asourcetoken.tokencode == flexer.getkeywordvalue("ALL"))) {
                        // RW_COMPRESS RW_FOR RW_ALL RW_OPERATIONS
                        // RW_COMPRESS RW_FOR RW_DIRECT_LOAD RW_OPERATIONS
                        // change rw_for to TBaseType.rw_for1, it conflicts with compress for update in create materialized view

                        lcprevst = getprevsolidtoken(asourcetoken);
                        if (lcprevst != null) {
                            if (lcprevst.tokencode == TBaseType.rrw_for)
                                lcprevst.tokencode = TBaseType.rw_for1;
                        }
                    }

                    if (asourcetoken.tokencode == TBaseType.rrw_dense_rank) {
                        //keep keyword can be column alias, make keep in keep_denserankclause as a different token code
                        TSourceToken stKeep = asourcetoken.searchToken(TBaseType.rrw_keep, -2);
                        if (stKeep != null) {
                            stKeep.tokencode = TBaseType.rrw_keep_before_dense_rank;
                        }
                    }

                    if ((asourcetoken.tokencode == TBaseType.rrw_postgresql_rowtype)
                            || (asourcetoken.tokencode == TBaseType.rrw_postgresql_type)) {
                        TSourceToken stPercent = asourcetoken.searchToken('%', -1);
                        if (stPercent != null) {
                            stPercent.tokencode = TBaseType.rowtype_operator;
                        }
                    }

                    if (asourcetoken.tokencode == TBaseType.JSON_EXIST) {
                        TSourceToken stPercent = asourcetoken.searchToken('=', -1);
                        if (stPercent != null) {    // = ?, ? after = should not be treated as json exist operator
                            asourcetoken.tokencode = TBaseType.ident;
                        }
                    }

                    if (asourcetoken.tokencode == TBaseType.rrw_update) { // on conflict do update in insert statement
                        TSourceToken stDo = asourcetoken.searchToken(TBaseType.rrw_do, -1);
                        if (stDo != null) {
                            asourcetoken.tokencode = TBaseType.rrw_postgresql_do_update;
                        }
                    }

                    break;
                }
            }
            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;
                    }
                }
            }
        }
    }

    /**
     * Check if a valid place for division operator to be treated as SQL*Plus command.
     * <p>
     * Migrated from TGSqlParser.IsValidPlaceForDivToSqlplusCmd() (lines 2641-2655).
     */
    private boolean isValidPlaceForDivToSqlplusCmd(TSourceTokenList pstlist, int pPos) {
        boolean ret = false;

        if ((pPos <= 0) || (pPos > pstlist.size() - 1)) return ret;
        //token directly before div must be ttreturn without space appending it
        TSourceToken lcst = pstlist.get(pPos - 1);
        if (lcst.tokentype != ETokenType.ttreturn) {
            return ret;
        }

        if (!(lcst.getAstext().charAt(lcst.getAstext().length() - 1) == ' ')) {
            ret = true;
        }

        return ret;
    }

    /**
     * Check if a string is a valid SQL*Plus command in PostgreSQL/Edb context.
     * <p>
     * Migrated from TGSqlParser.isvalidsqlpluscmdInPostgresql() (lines 2658-2660).
     * <p>
     * Note: This is a placeholder function that always returns false.
     */
    private boolean isvalidsqlpluscmdInPostgresql(String astr) {
        return false;
    }

    /**
     * Get the previous solid token before the given token.
     * <p>
     * Migrated from TGSqlParser.getprevsolidtoken() (lines 2752-2773).
     */
    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 = getprevsolidtoken(lctokenlist.get(ptoken.posinlist - 1));
                }
            }
        }
        return ret;
    }

    /**
     * Find package name in Edb package statements.
     * <p>
     * Migrated from TGSqlParser.findPkgName() (lines 7437-7485).
     * <p>
     * @param st Starting token
     * @param mode 1=package spec, 2=package body, 3=package name after END
     * @return Package name string
     */
    private String findPkgName(TSourceToken st, int mode) {
        String pkgName = "";

        boolean inpkgname = false;
        if (mode == 3) inpkgname = true;
        int MAX_TRY_TOKENS = 20;
        int tryTokens = 0;
        while (st != null) {

            if (st.isnonsolidtoken()) {
                st = st.getNextTokenInChain();
                continue;
            }
            tryTokens++;

            if ((mode == 1) && (st.tokencode == TBaseType.rrw_package)) {
                inpkgname = true;
                st = st.getNextTokenInChain();
                continue;
            } else if ((mode == 2) && (st.tokencode == TBaseType.rrw_body)) {
                inpkgname = true;
                st = st.getNextTokenInChain();
                continue;
            }

            if (((mode == 1) || (mode == 2))
                    && ((st.tokencode == TBaseType.rrw_is) || (st.tokencode == TBaseType.rrw_as))
            ) {
                break;
            } else if ((mode == 3) && (st.tokencode == ';')) {
                break;
            }

            if (!inpkgname) {
                st = st.getNextTokenInChain();
                continue;
            }
            pkgName = pkgName + st.toString();
            st = st.getNextTokenInChain();

            if (tryTokens > MAX_TRY_TOKENS) {
                TBaseType.log(String.format("Package name is not found in create package"), TLog.ERROR, st);
                break;
            }
        }

        return pkgName;
    }

    // ========== Phase 3: Raw Statement Extraction (Hook Pattern) ==========

    @Override
    protected void setupVendorParsersForExtraction() {
        this.fparser.sqlcmds = this.sqlcmds;
        this.fparser.sourcetokenlist = this.sourcetokenlist;
    }

    @Override
    protected void extractVendorRawStatements(SqlParseResult.Builder builder) {
        doedbgetrawsqlstatements(builder);
    }

    /**
     * Extract raw SQL statements from token list.
     * <p>
     * Migrated from TGSqlParser.doedbgetrawsqlstatements() (lines 7495-8049).
     * <p>
     * This method implements a state machine to identify statement boundaries:
     * <ul>
     *   <li>Regular SQL statements terminated by semicolon</li>
     *   <li>Oracle-style stored procedures with BEGIN/END pairs</li>
     *   <li>PostgreSQL-style procedures with $$ delimiters</li>
     *   <li>Package specifications and bodies with Edb-specific state tracking</li>
     *   <li>Slash (/) and period (.) terminators for procedural blocks</li>
     * </ul>
     */
    private void doedbgetrawsqlstatements(SqlParseResult.Builder builder) {
        int waitingEnd = 0;
        boolean foundEnd = false;
        int declarePending = 0; // tracks nested IS/AS/DECLARE without matching BEGIN
        isOracleStyleRoutine = true;
        stProcedure = null;
        stFunction = null;

        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;

        // Handle single PL block mode
        if (parserContext != null && parserContext.isSinglePLBlock()) {
            gcurrentsqlstatement = new TCommonBlock(vendor);
        }

        for (int i = 0; i < sourcetokenlist.size(); i++) {

            if ((ast != null) && (ast.issolidtoken()))
                lcprevsolidtoken = ast;

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

            if (parserContext != null && parserContext.isSinglePLBlock()) {
                gcurrentsqlstatement.sourcetokenlist.add(ast);
                continue;
            }

            // Token preprocessing: Adjust token codes based on context
            if (ast.tokencode == TBaseType.JSON_EXIST) {
                TSourceToken stConstant = ast.searchToken(TBaseType.sconst, 1);
                if (stConstant == null) {
                    ast.tokencode = TBaseType.ident;
                }
            } else if (ast.tokencode == TBaseType.rrw_postgresql_POSITION) {
                TSourceToken st1 = ast.nextSolidToken();
                if (st1 != null) {
                    if (st1.tokencode == '(') {
                        ast.tokencode = TBaseType.rrw_postgresql_POSITION_FUNCTION;
                    }
                }
            } else if (ast.tokencode == TBaseType.rrw_postgresql_ordinality) {
                TSourceToken lcprevst = getprevsolidtoken(ast);

                if (lcprevst != null) {
                    if (lcprevst.tokencode == TBaseType.rrw_with) {
                        TSourceToken lcnextst = ast.nextSolidToken();
                        if ((lcnextst != null) && (lcnextst.tokencode == TBaseType.rrw_as)) {
                            // with ordinality as (select 1 as x) select * from ordinality;
                            // don't change with to rrw_postgresql_with_lookahead
                        } else {
                            lcprevst.tokencode = TBaseType.rrw_postgresql_with_lookahead;
                        }

                    }
                }
            } else if ((ast.tokencode == TBaseType.rrw_postgresql_filter)
                    || (ast.tokencode == TBaseType.GAUSSDB_TO_BINARY_DOUBLE)
                    || (ast.tokencode == TBaseType.GAUSSDB_TO_BINARY_FLOAT)
                    || (ast.tokencode == TBaseType.GAUSSDB_TO_NUMBER)
                    || (ast.tokencode == TBaseType.GAUSSDB_TO_DATE)
                    || (ast.tokencode == TBaseType.GAUSSDB_TO_TIMESTAMP)
                    || (ast.tokencode == TBaseType.GAUSSDB_TO_TIMESTAMP_TZ)
            ) {
                TSourceToken st1 = ast.nextSolidToken();
                if (st1 != null) {
                    if (st1.tokencode == '(') {
                        // Keep as function
                    } else {
                        ast.tokencode = TBaseType.ident;
                    }
                }
            } else if (ast.tokencode == TBaseType.rrw_postgresql_jsonb) {
                TSourceToken st1 = ast.nextSolidToken();
                if (st1 != null) {
                    if (st1.tokencode == '?') {
                        st1.tokencode = TBaseType.OP_JSONB_QUESTION;
                    }
                }
            } else if (ast.tokencode == TBaseType.GAUSSDB_TO_NUMBER) {
                TSourceToken st1 = ast.searchToken('(', 1);
                if (st1 == null) {
                    ast.tokencode = TBaseType.ident;
                }
            } else if (ast.tokencode == '?') {
                TSourceToken st1 = ast.nextSolidToken();
                if (st1 != null) {
                    if (st1.tokencode == TBaseType.sconst) {
                        ast.tokencode = TBaseType.OP_JSONB_QUESTION;
                    }
                }
            } 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
                            } else {
                                ast.tokencode = TBaseType.rrw_postgresql_insert_values;
                            }
                        }
                    }
                }
            }

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

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

                    if (gcurrentsqlstatement != null) {
                        declarePending = 0;
                        if (gcurrentsqlstatement.isGaussDBStoredProcedure()) {
                            appendToken(gcurrentsqlstatement, ast);
                            if (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstplsql_createpackage) {
                                gst = EFindSqlStateType.stGaussDBPkgSpec;
                                TPlsqlCreatePackage pkgspec = (TPlsqlCreatePackage) gcurrentsqlstatement;
                                pkgspec.setPackageNameStr(findPkgName(ast.getNextTokenInChain(), 1));
                            } else if (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstoraclecreatepackagebody) {
                                gst = EFindSqlStateType.stGaussDBPkgBody;
                                TPlsqlCreatePackage pkgspec = (TPlsqlCreatePackage) gcurrentsqlstatement;
                                pkgspec.setPackageNameStr(findPkgName(ast.getNextTokenInChain(), 2));
                            } else {
                                gst = EFindSqlStateType.ststoredprocedure;

                                foundEnd = false;
                                if ((ast.tokencode == TBaseType.rrw_begin)
                                        || (ast.tokencode == TBaseType.rrw_package)
                                        || (ast.searchToken(TBaseType.rrw_package, 4) != null)
                                ) {
                                    waitingEnd = 1;
                                } else if (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstplsql_createtypebody) {
                                    // CREATE TYPE BODY has AS...END wrapper around member definitions
                                    // each member has its own BEGIN...END, so we need an extra nesting level
                                    waitingEnd = 1;
                                } else if (ast.tokencode == TBaseType.rrw_declare) {
                                    declarePending = 1;
                                }

                                if (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateprocedure) {
                                    // create procedure, create or replace procedure
                                    stProcedure = ast.searchToken(TBaseType.rrw_procedure, 3);
                                } else if (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatefunction) {
                                    // create function, create or replace function
                                    stFunction = ast.searchToken(TBaseType.rrw_function, 3);
                                }
                            }
                        } else {
                            gst = EFindSqlStateType.stsql;
                            appendToken(gcurrentsqlstatement, ast);
                        }
                    } else {
                        //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;
                        appendToken(gcurrentsqlstatement, ast);

                    }

                    break;
                } // stnormal

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

                    break;
                }//case stsqlplus

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

                    if (sourcetokenlist.sqlplusaftercurtoken()) { //most probably is / cmd
                        // In Edb, if / appears in regular SQL (non-stored procedure) and is identified as sqlplus,
                        // it should be a false positive. For example, in division expressions.
                        // We need to restore / to a regular character /
                        TSourceToken st = ast.nextSolidToken();
                        if (st.tokentype == ETokenType.ttslash) {
                            st.tokencode = '/';
                        } else { // Non-/ sqlplus commands are still treated as sqlplus, but whether Edb has Oracle-like sqlplus needs further verification
                            gst = EFindSqlStateType.stnormal;
                            appendToken(gcurrentsqlstatement, ast);
                            onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.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(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                            continue;
                        }
                    }

                    appendToken(gcurrentsqlstatement, ast);
                    break;
                }//case stsql

                case ststoredprocedure: {
                    if (ast.tokencode == TBaseType.rrw_postgresql_function_delimiter) {
                        appendToken(gcurrentsqlstatement, ast);
                        isOracleStyleRoutine = false;
                        gst = EFindSqlStateType.ststoredprocedurePgStartBody;
                        continue;
                    }

                    if (ast.tokencode == TBaseType.rrw_postgresql_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());
                                isOracleStyleRoutine = false;
                            }
                        }
                    }

                    if ((ast.tokentype == ETokenType.ttsemicolon) && (waitingEnd == 0) && (declarePending == 0)) {
                        gst = EFindSqlStateType.stnormal;
                        appendToken(gcurrentsqlstatement, ast);
                        gcurrentsqlstatement.semicolonended = ast;

                        onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                        continue;
                    }

                    // Compound trigger: COMPOUND TRIGGER adds an extra nesting level
                    // because the body has internal END...;  for each timing point section
                    // but the outer END trigger_name; is the real end of the trigger.
                    if (ast.toString().equalsIgnoreCase("COMPOUND")) {
                        TSourceToken nextSt2 = ast.nextSolidToken();
                        if (nextSt2 != null && nextSt2.toString().equalsIgnoreCase("TRIGGER")) {
                            waitingEnd++;
                        }
                    }

                    if ((ast.tokencode == TBaseType.rrw_begin)
                    ) {
                        waitingEnd++;
                        if (declarePending > 0) {
                            declarePending--;
                        }
                    } else if (
                            (ast.tokencode == TBaseType.rrw_declare)
                                    || (ast.tokencode == TBaseType.rrw_as) || (ast.tokencode == TBaseType.rrw_is)
                    ) {
                        TSourceToken next = ast.nextSolidToken();
                        if ((next != null) && ((next.tokencode == TBaseType.sconst) || (next.tokencode == TBaseType.GAUSSDB_NULL))) {
                            // CREATE FUNCTION func_add_sql(integer, integer) RETURNS integer
                            //    AS 'select $1 + $2;'
                            //    LANGUAGE SQL
                            //    IMMUTABLE
                            //    RETURNS NULL ON NULL INPUT;
                        } else {
                            declarePending++;
                        }
                    } 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)) //and (prevst.NewlineIsLastTokenInTailerToken)) then
                    {
                        // TPlsqlStatementParse(asqlstatement).TerminatorToken := ast;
                        ast.tokenstatus = ETokenStatus.tsignorebyyacc;
                        gst = EFindSqlStateType.stnormal;

                        onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);

                        //make / a sqlplus cmd
                        gcurrentsqlstatement = new TSqlplusCmdStatement(vendor);
                        appendToken(gcurrentsqlstatement, ast);
                        onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.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(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);

                        //make ttperiod a sqlplus cmd
                        gcurrentsqlstatement = new TSqlplusCmdStatement(vendor);
                        appendToken(gcurrentsqlstatement, ast);
                        onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                    } else {
                        appendToken(gcurrentsqlstatement, ast);
                        if ((ast.tokentype == ETokenType.ttsemicolon) && (waitingEnd == 0) && (declarePending == 0)
                                && (foundEnd)
                        ) {
                            gst = EFindSqlStateType.stnormal;
                            onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.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(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                        }
                    }

                    break;
                } //ststoredprocedure

                case ststoredprocedurePgStartBody: {
                    appendToken(gcurrentsqlstatement, ast);

                    if (ast.tokencode == TBaseType.rrw_postgresql_function_delimiter) {
                        gst = EFindSqlStateType.ststoredprocedurePgEndBody;
                        continue;
                    }

                    break;
                }

                case ststoredprocedurePgEndBody: {

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

                    appendToken(gcurrentsqlstatement, ast);

                    if (ast.tokencode == TBaseType.rrw_postgresql_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;
                }

                case stGaussDBPkgSpec: {
                    appendToken(gcurrentsqlstatement, ast);

                    if (ast.tokencode == TBaseType.rrw_end) {
                        TPlsqlCreatePackage plsqlCreatePackage = (TPlsqlCreatePackage) gcurrentsqlstatement;

                        String pkgName = findPkgName(ast.getNextTokenInChain(), 3);
                        if ((pkgName != null) && (pkgName.equalsIgnoreCase(plsqlCreatePackage.getPackageNameStr()))) {
                            gst = EFindSqlStateType.stGaussDBPkgSpecEnd;
                        }
                    }
                    break;
                }
                case stGaussDBPkgSpecEnd: {
                    appendToken(gcurrentsqlstatement, ast);
                    if (ast.tokencode == ';') {
                        gst = EFindSqlStateType.stnormal;
                        onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                        continue;
                    }
                    break;
                }

                case stGaussDBPkgBody: {
                    appendToken(gcurrentsqlstatement, ast);
                    if (ast.tokencode == TBaseType.rrw_end) {
                        TPlsqlCreatePackage plsqlCreatePackage = (TPlsqlCreatePackage) gcurrentsqlstatement;

                        String pkgName = findPkgName(ast.getNextTokenInChain(), 3);
                        if ((pkgName != null) && (pkgName.equalsIgnoreCase(plsqlCreatePackage.getPackageNameStr()))) {
                            gst = EFindSqlStateType.stGaussDBPkgBodyEnd;
                        }
                    }
                    break;
                }
                case stGaussDBPkgBodyEnd: {
                    appendToken(gcurrentsqlstatement, ast);
                    if (ast.tokencode == ';') {
                        gst = EFindSqlStateType.stnormal;
                        onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                        continue;
                    }
                    break;
                }

            } //switch
        }//for

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

        // Populate builder with extracted statements
        builder.sqlStatements(this.sqlstatements);
        builder.errorCode(0);
        builder.errorMessage("");
    }

    /**
     * Helper method to append a token to a statement.
     * <p>
     * Sets the token's statement reference and adds it to the statement's token list.
     */
    private void appendToken(TCustomSqlStatement statement, TSourceToken token) {
        if (statement == null || token == null) {
            return;
        }
        token.stmt = statement;
        statement.sourcetokenlist.add(token);
    }

    // ========== Phase 4: Statement Parsing ==========

    @Override
    protected TStatementList performParsing(ParserContext context, TCustomParser parser,
                                            TCustomParser secondaryParser, TSourceTokenList tokens,
                                            TStatementList rawStatements) {
        if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE) {
            System.out.println("EdbSqlParser.performParsing() CALLED with " +
                    (rawStatements != null ? rawStatements.size() : 0) + " statements");
        }

        // Store references
        this.fparser = (TParserEdb) parser;
        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
        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 {
                stmt.setFrameStack(frameStack);
                int parseResult = stmt.parsestatement(null, false, context.isOnlyNeedRawParseTree());

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

    /**
     * Handle CREATE TABLE error recovery.
     * <p>
     * Migrated from TGSqlParser.doparse() error recovery logic.
     * <p>
     * Attempts to recover from parsing errors in CREATE TABLE statements by
     * marking unparseable table properties as sqlpluscmd and retrying.
     * This allows parsing CREATE TABLE statements with vendor-specific extensions
     * that may not be in the grammar.
     */
    private void handleCreateTableErrorRecovery(TCustomSqlStatement stmt) {
        // Check if this is a CREATE TABLE or CREATE INDEX statement
        if (!(stmt.sqlstatementtype == ESqlStatementType.sstcreatetable ||
                stmt.sqlstatementtype == ESqlStatementType.sstcreateindex)) {
            return;
        }

        // Check if strict parsing is disabled
        if (TBaseType.c_createTableStrictParsing) {
            return;
        }

        TCustomSqlStatement errorSqlStatement = stmt;

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

        // Iterate through tokens to find the closing parenthesis of table definition
        for (int k = 0; k < errorSqlStatement.sourcetokenlist.size(); k++) {
            TSourceToken st = errorSqlStatement.sourcetokenlist.get(k);

            if (isIgnore) {
                // We're past the table definition, mark tokens as ignoreable
                if (st.issolidtoken() && (st.tokencode != ';')) {
                    isFoundIgnoreToken = true;
                    if (firstIgnoreToken == null) {
                        firstIgnoreToken = st;
                    }
                }
                // Mark all tokens (except semicolon) as sqlpluscmd to ignore them
                if (st.tokencode != ';') {
                    st.tokencode = TBaseType.sqlpluscmd;
                }
                continue;
            }

            // Track closing parentheses
            if (st.tokencode == (int) ')') {
                nested--;
                if (nested == 0) {
                    // Found the closing parenthesis of table definition
                    // Check if next tokens are "AS ( SELECT" (CTAS pattern)
                    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 not a CTAS, start ignoring subsequent tokens
                    if (!isSelect) {
                        isIgnore = true;
                    }
                }
            }

            // Track opening parentheses
            if ((st.tokencode == (int) '(') || (st.tokencode == TBaseType.left_parenthesis_2)) {
                nested++;
            }
        }

        // If we found ignoreable tokens, clear errors and retry parsing
        if (isFoundIgnoreToken) {
            errorSqlStatement.clearError();
            int retryResult = errorSqlStatement.parsestatement(null, false, parserContext.isOnlyNeedRawParseTree());
        }
    }

    // ========== Phase 5: Semantic Analysis & Interpretation ==========

    @Override
    protected void performSemanticAnalysis(ParserContext context, TStatementList statements) {
        if (!TBaseType.isEnableResolver()) {
            return;
        }

        if (getSyntaxErrors().isEmpty()) {
            TSQLResolver resolver = new TSQLResolver(this.globalContext, statements);
            resolver.resolve();
        }
    }

    @Override
    protected void performInterpreter(ParserContext context, TStatementList statements) {
        if (!TBaseType.ENABLE_INTERPRETER) {
            return;
        }

        if (getSyntaxErrors().isEmpty()) {
            TGlobalScope interpreterScope = new TGlobalScope(sqlEnv);
            TASTEvaluator astEvaluator = new TASTEvaluator(statements, interpreterScope);
            astEvaluator.eval();
        }
    }

    // ========== Vendor-Specific Statement Completion ==========

    /**
     * Edb-specific statement completion logic.
     * <p>
     * Migrated from TGSqlParser.doongetrawsqlstatementevent() (lines 5129-5141).
     * <p>
     * For CREATE PROCEDURE/FUNCTION statements, marks Oracle-style routines
     * by setting special token codes to distinguish them from PostgreSQL-style routines.
     *
     * @param statement the completed statement
     */
    @Override
    protected void onRawStatementCompleteVendorSpecific(TCustomSqlStatement statement) {
        // First, call parent implementation for PostgreSQL-family logic
        // (Edb inherits PostgreSQL compatibility, so this applies too)
        super.onRawStatementCompleteVendorSpecific(statement);

        // Edb-specific: Mark Oracle-style procedures/functions
        // Migrated from TGSqlParser.doongetrawsqlstatementevent() lines 5129-5141
        if ((statement.sqlstatementtype == ESqlStatementType.sstcreateprocedure)
                || (statement.sqlstatementtype == ESqlStatementType.sstcreatefunction)) {

            if (isOracleStyleRoutine) {
                if (stFunction != null) {
                    stFunction.tokencode = TBaseType.GAUSSDB_FUNCTION_ORA;
                } else if (stProcedure != null) {
                    stProcedure.tokencode = TBaseType.GAUSSDB_PROCEDURE_ORA;
                }
            }

            // Reset state for next statement
            stFunction = null;
            stProcedure = null;
            isOracleStyleRoutine = true;
        }
    }

    @Override
    public EDbVendor getVendor() {
        return vendor;
    }

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