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.TLexerDb2;
import gudusoft.gsqlparser.TParserDb2Sql;
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.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 java.util.ArrayList;

/**
 * IBM DB2 SQL parser implementation.
 *
 * <p>This parser handles DB2-specific SQL syntax including:
 * <ul>
 *   <li>DB2 SQL procedures and functions</li>
 *   <li>DB2-specific triggers</li>
 *   <li>DECLARE CURSOR and compound statements</li>
 *   <li>DB2 echo commands treated as SQL*Plus commands</li>
 *   <li>JDBC escape sequences</li>
 *   <li>WITH isolation clauses</li>
 * </ul>
 *
 * <p><b>Design Notes:</b>
 * <ul>
 *   <li>Extends {@link AbstractSqlParser}</li>
 *   <li>Can directly instantiate: {@link TLexerDb2}, {@link TParserDb2Sql}</li>
 *   <li>Uses single parser (no secondary parser)</li>
 *   <li>Delimiter character: '@' for stored procedures (not ';')</li>
 * </ul>
 *
 * <p><b>Migrated from TGSqlParser:</b>
 * <ul>
 *   <li>dodb2sqltexttotokenlist() → tokenizeVendorSql()</li>
 *   <li>dodb2getrawsqlstatements() → extractVendorRawStatements()</li>
 * </ul>
 *
 * @see SqlParser
 * @see AbstractSqlParser
 * @see TLexerDb2
 * @see TParserDb2Sql
 * @since 3.2.0.0
 */
public class Db2SqlParser extends AbstractSqlParser {

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

    public TLexerDb2 flexer;
    private TParserDb2Sql fparser;

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

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

    /**
     * Construct DB2 SQL parser.
     * <p>
     * Configures the parser for IBM DB2 database with default delimiter: at-sign (@)
     * <p>
     * Following the original TGSqlParser pattern, the lexer and parser are
     * created once in the constructor and reused for all parsing operations.
     * <p>
     * <b>Note:</b> DB2 uses '@' as the statement delimiter (not ';' like most databases).
     * This is consistent with DB2 stored procedure conventions where @ marks the end of a procedure.
     */
    public Db2SqlParser() {
        super(EDbVendor.dbvdb2);

        // Set delimiter character - DB2 uses '@' not ';'
        this.delimiterChar = '@';
        this.defaultDelimiterStr = "@";

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

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

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

    /**
     * Return the DB2 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 DB2 lexer instance created in constructor
     */
    @Override
    protected TCustomLexer getLexer(ParserContext context) {
        // Return existing lexer instance (created in constructor)
        return this.flexer;
    }

    /**
     * Return the DB2 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 DB2 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 DB2-specific tokenization logic.
     * <p>
     * Delegates to dodb2sqltexttotokenlist which handles DB2's
     * specific keyword recognition, JDBC escapes, and token generation.
     */
    @Override
    protected void tokenizeVendorSql() {
        dodb2sqltexttotokenlist();
    }

    /**
     * Setup DB2 parser for raw statement extraction.
     * <p>
     * DB2 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 DB2-specific raw statement extraction logic.
     * <p>
     * Delegates to dodb2getrawsqlstatements which handles DB2's
     * statement boundaries, stored procedures, and compound blocks.
     *
     * @param builder result builder to populate
     */
    @Override
    protected void extractVendorRawStatements(SqlParseResult.Builder builder) {
        dodb2getrawsqlstatements(builder);
    }

    /**
     * Perform full parsing on raw DB2 SQL statements.
     * <p>
     * This method parses each raw statement into a complete parse tree,
     * handling stored procedures, functions, triggers, and nested blocks.
     *
     * @param context parser context
     * @param parser main parser instance
     * @param secondaryParser secondary parser (null for DB2)
     * @param tokens source token list
     * @param rawStatements raw statements to parse
     * @return list of parsed statements
     */
    @Override
    protected TStatementList performParsing(ParserContext context,
                                           TCustomParser parser,
                                           TCustomParser secondaryParser,
                                           TSourceTokenList tokens,
                                           TStatementList rawStatements) {
        // Store references
        this.fparser = (TParserDb2Sql) parser;
        this.sourcetokenlist = tokens;
        this.parserContext = context;

        // Use rawStatements if provided, otherwise use our own sqlstatements field
        if (rawStatements != null) {
            this.sqlstatements = rawStatements;
        }

        // Safety check - if sqlstatements is still null, return empty list
        if (this.sqlstatements == null) {
            return new TStatementList();
        }

        // Initialize sqlcmds if not already done
        if (this.sqlcmds == null) {
            this.sqlcmds = SqlCmdsFactory.get(vendor);
        }
        this.fparser.sqlcmds = this.sqlcmds;

        // Use inherited method to initialize global context
        initializeGlobalContext();

        // Parse each statement with exception handling
        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());

                // Perform any DB2-specific post-processing if needed
                afterStatementParsed(stmt);

                // Attempt error recovery for CREATE TABLE/INDEX with unsupported options
                // This matches legacy TGSqlParser behavior that ignores vendor-specific
                // table/index options not in the grammar
                if ((parseResult != 0) || (stmt.getErrorCount() > 0)) {
                    parseResult = attemptErrorRecovery(stmt, parseResult, context.isOnlyNeedRawParseTree());
                }

                // Collect errors from statement (after recovery attempt)
                if ((parseResult != 0) || (stmt.getErrorCount() > 0)) {
                    copyErrorsFromStatement(stmt);
                }
            } catch (Exception ex) {
                // Use inherited exception handler
                handleStatementParsingException(stmt, i, ex);
                continue;
            }
        }

        // Cleanup
        if (globalFrame != null) {
            globalFrame.popMeFromStack(frameStack);
        }

        return sqlstatements;
    }

    // ========== DB2-Specific Tokenization ==========
    // Migrated from TGSqlParser.dodb2sqltexttotokenlist()

    /**
     * Tokenize DB2 SQL text into source tokens.
     * <p>
     * Handles DB2-specific features:
     * <ul>
     *   <li>Echo commands at line start treated as SQL*Plus commands</li>
     *   <li>JDBC escape sequences {fn} and }</li>
     *   <li>WITH isolation clauses (RR, RS, CS, UR)</li>
     *   <li>ScriptOptions comment directive</li>
     * </ul>
     * <p>
     * Migrated from TGSqlParser.dodb2sqltexttotokenlist (lines 4300-4408)
     */
    private void dodb2sqltexttotokenlist() {
        // treat echo, ! of db2 at the begin of each line as oracle sqlplus command

        boolean insqlpluscmd = false;
        boolean isvalidplace = true;
        int jdbc_escape_nest = 0;

        TSourceToken asourcetoken, lcprevst;
        int yychar;

        asourcetoken = getanewsourcetoken();

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

        while (yychar > 0) {

            switch (yychar) {
                case TBaseType.lexnewline: {
                    insqlpluscmd = false;
                    isvalidplace = true;
                    break;
                }
                case TBaseType.cmtdoublehyphen: {
                    if (asourcetoken.toString().toLowerCase().indexOf("scriptoptions") >= 0) {
                        asourcetoken.tokencode = TBaseType.scriptoptions;
                        asourcetoken.tokentype = ETokenType.ttidentifier;
                    }

                    if (insqlpluscmd) {
                        asourcetoken.insqlpluscmd = true;
                    }
                    break;
                }
                case TBaseType.rrw_jdbc_escape_fn: {
                    jdbc_escape_nest++;
                    asourcetoken.tokencode = TBaseType.lexspace;
                    break;
                }
                case TBaseType.rrw_jdbc_escape_end: {
                    jdbc_escape_nest--;
                    asourcetoken.tokencode = TBaseType.lexspace;
                    break;
                }
                default: // solid tokentext
                {
                    if ((asourcetoken.tokencode == TBaseType.rrw_rr)
                            || (asourcetoken.tokencode == TBaseType.rrw_rs)
                            || (asourcetoken.tokencode == TBaseType.rrw_cs)
                            || (asourcetoken.tokencode == TBaseType.rrw_ur)) {
                        // change with keyword in isolation clause to rrw_with_isolation
                        // so opt_restriction_clause in create view worked correctly
                        lcprevst = getprevsolidtoken(asourcetoken);
                        if (lcprevst != null) {
                            if (lcprevst.tokencode == TBaseType.rrw_with)
                                lcprevst.tokencode = TBaseType.rrw_with_isolation;
                        }
                    }

                    if (insqlpluscmd) {
                        asourcetoken.insqlpluscmd = true;
                    } else {
                        if (isvalidplace) {
                            if (TBaseType.mycomparetext(asourcetoken.toString().toLowerCase(), "echo") == 0) {
                                asourcetoken.tokencode = TBaseType.sqlpluscmd;
                                if (asourcetoken.tokentype != ETokenType.ttslash) {
                                    asourcetoken.tokentype = ETokenType.ttsqlpluscmd;
                                }
                                asourcetoken.insqlpluscmd = true;
                                insqlpluscmd = true;
                            }
                        }
                    }
                    isvalidplace = false;

                    break;
                } // end of solid tokentext
            } // switch

            sourcetokenlist.add(asourcetoken);

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

        } // while
    }

    // ========== DB2-Specific Raw Statement Extraction ==========
    // Migrated from TGSqlParser.dodb2getrawsqlstatements()

    /**
     * Extract raw DB2 SQL statements from token list.
     * <p>
     * Handles DB2-specific statement boundaries:
     * <ul>
     *   <li>Stored procedures, functions, triggers with BEGIN/END blocks</li>
     *   <li>DECLARE CURSOR statements</li>
     *   <li>Compound statements with nested blocks</li>
     *   <li>Echo commands as SQL*Plus commands</li>
     *   <li>Token transformations (DECLARE GLOBAL, YEAR as alias, TRIM L/R)</li>
     * </ul>
     * <p>
     * Migrated from TGSqlParser.dodb2getrawsqlstatements (lines 15346-15622)
     *
     * @param builder result builder to populate with extracted statements
     */
    private void dodb2getrawsqlstatements(SqlParseResult.Builder builder) {
        // Clear and initialize sqlstatements
        if (TBaseType.assigned(sqlstatements)) {
            sqlstatements.clear();
        }

        // Check if sourcetokenlist is available
        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;
        }

        TCustomSqlStatement gcurrentsqlstatement = null;
        EFindSqlStateType gst = EFindSqlStateType.stnormal;
        int i, c;
        TSourceToken ast;
        int errorcount = 0;
        char ch;
        String lcstr;
        int waitingEnds = 0;
        boolean waitingForFirstBegin = false;
        char curDelimiterChar = delimiterChar;

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

            // Token transformations
            if (ast.tokencode == TBaseType.rrw_declare) {
                TSourceToken st1 = ast.searchToken("global", 1);
                if (st1 != null) {
                    ast.tokencode = TBaseType.rrw_declare_global;
                }
            } else if ((ast.tokencode == TBaseType.rrw_year) || (ast.tokencode == TBaseType.rrw_db2_second)
                    || (ast.tokencode == TBaseType.rrw_db2_current)) {
                TSourceToken st1 = ast.searchToken('.', 1);
                if (st1 != null) {
                    // year.columnA, year is a table alias
                    ast.tokencode = TBaseType.ident;
                }
            } else if ((ast.tokencode == TBaseType.rrw_db2_trim_l) || (ast.tokencode == TBaseType.rrw_db2_trim_r)) {
                TSourceToken st1 = ast.searchToken(TBaseType.rrw_db2_trim, -2);
                if (st1 == null) {
                    // not L,R in TRIM (R 'Mr.' FROM name)
                    ast.tokencode = TBaseType.ident;
                }
            }

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

                    if (ast.tokencode == TBaseType.sqlpluscmd) {
                        // echo in db2 is treated as sqlplus cmd
                        gst = EFindSqlStateType.stsqlplus;
                        gcurrentsqlstatement = new TSqlplusCmdStatement(vendor);
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        continue;
                    }

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

                    if (TBaseType.assigned(gcurrentsqlstatement)) {
                        ESqlStatementType[] ses = {ESqlStatementType.sstdb2declarecursor, ESqlStatementType.sstcreateprocedure,
                                ESqlStatementType.sstcreatefunction, ESqlStatementType.sstcreatetrigger, ESqlStatementType.sst_plsql_block,
                                ESqlStatementType.sstdb2alterfunction, ESqlStatementType.sstdb2alterprocedure};
                        if (includesqlstatementtype(gcurrentsqlstatement.sqlstatementtype, ses)) {
                            gst = EFindSqlStateType.ststoredprocedure;
                            waitingEnds = 1; // need a END keyword to end this procedure
                            waitingForFirstBegin = true;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            if ((gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateprocedure)
                                    || (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatefunction)
                                    || (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger)
                                    || (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdb2alterfunction)
                                    || (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdb2alterprocedure)) {
                                curDelimiterChar = ';';
                            }
                        } else if (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstdb2scriptOption) {
                            gst = EFindSqlStateType.stnormal;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        } else {
                            gst = EFindSqlStateType.stsql;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                        }

                    }

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

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

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

                    }
                    break;
                }
                case stsqlplus: // treat echo, ! of db2 at the begin of each line as oracle sqlplus command
                {
                    if (ast.insqlpluscmd) {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                    } else {
                        gst = EFindSqlStateType.stnormal; // this tokentext must be newline,
                        gcurrentsqlstatement.sourcetokenlist.add(ast); // so add it here
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                    }
                    break;
                }
                case stsql: {
                    if (ast.tokentype == ETokenType.ttsemicolon) {
                        gst = EFindSqlStateType.stnormal;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        gcurrentsqlstatement.semicolonended = ast;
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        continue;
                    }
                    gcurrentsqlstatement.sourcetokenlist.add(ast);

                    break;
                }
                case ststoredprocedure: {
                    TCustomSqlStatement nextStmt = sqlcmds.issql(ast, gst, gcurrentsqlstatement);
                    if ((nextStmt != null)
                            && ((nextStmt.sqlstatementtype == ESqlStatementType.sstcreateprocedure)
                            || (nextStmt.sqlstatementtype == ESqlStatementType.sstcreatefunction)
                            || (nextStmt.sqlstatementtype == ESqlStatementType.sstcreatetrigger))) {
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        gcurrentsqlstatement = nextStmt;
                        gst = EFindSqlStateType.ststoredprocedure;
                        waitingEnds = 1; // need a END keyword to end this procedure
                        waitingForFirstBegin = true;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        curDelimiterChar = ';';
                        continue;
                    }

                    // single stmt in function/procedure/trigger may use ; as terminate char
                    // so default terminate char is ;, if begin is found, then
                    // set terminate char to DelimiterChar
                    if (curDelimiterChar != delimiterChar) {
                        if ((ast.tokencode == TBaseType.rrw_begin) || (ast.tokencode == TBaseType.rrw_declare)) {
                            curDelimiterChar = delimiterChar;
                        }
                    }

                    if (curDelimiterChar == ';') {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        if (ast.tokentype == ETokenType.ttsemicolon) {
                            gst = EFindSqlStateType.stnormal;
                            gcurrentsqlstatement.semicolonended = ast;
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            continue;
                        }
                    } else {
                        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) {
                                lcstr = ast.getAstext().substring(0, ast.getAstext().length() - 1);
                                if ((c = flexer.getkeywordvalue(lcstr)) > 0)
                                    ast.tokencode = c;
                            } else {
                                gcurrentsqlstatement.semicolonended = ast;
                            }
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            gst = EFindSqlStateType.stnormal;
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        } else {
                            gcurrentsqlstatement.sourcetokenlist.add(ast);

                            if ((ast.tokencode == TBaseType.rrw_case)
                                    || (ast.tokencode == TBaseType.rrw_for)
                                    || (ast.tokencode == TBaseType.rrw_if)
                                    || (ast.tokencode == TBaseType.rrw_while)
                                    || (ast.tokencode == TBaseType.rrw_repeat)
                                    || (ast.tokencode == TBaseType.rrw_loop)) {
                                TSourceToken nextst = ast.nextSolidToken();
                                if (nextst != null) {
                                    if (nextst.tokencode != ';') {
                                        waitingEnds++;
                                    }
                                }

                            } else if (ast.tokencode == TBaseType.rrw_begin) {
                                if (waitingForFirstBegin) {
                                    waitingForFirstBegin = false;
                                } else {
                                    waitingEnds++;
                                }
                            } else if (ast.tokencode == TBaseType.rrw_end) {
                                waitingEnds--;
                            }

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

                        }
                    } // end of DelimiterChar

                    break;
                } // db2 sp
            } // case
        } // for

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

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

    /**
     * Get previous non-whitespace/comment token.
     * <p>
     * Helper method for tokenization that finds the previous "solid" token
     * (skipping whitespace, newlines, and comments).
     *
     * @param ptoken current token
     * @return previous solid token, or null if not found
     */
    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;
    }

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

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