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;
// Note: Generated lexer class has lowercase 'a' in class name
import gudusoft.gsqlparser.TLexerathena;
import gudusoft.gsqlparser.TParserAthena;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSourceTokenList;
import gudusoft.gsqlparser.TStatementList;
import gudusoft.gsqlparser.TSyntaxError;
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.TCreateTableSqlStatement;
import gudusoft.gsqlparser.stmt.TUnknownSqlStatement;
import gudusoft.gsqlparser.stmt.oracle.TSqlplusCmdStatement;

import java.util.Stack;

/**
 * AWS Athena SQL parser implementation.
 *
 * <p>This parser handles Athena-specific SQL syntax including:
 * <ul>
 *   <li>Presto/Trino-based SQL syntax</li>
 *   <li>MySQL-style comment handling</li>
 *   <li>PL/SQL-like procedural blocks (BEGIN/END)</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 Athena parser</li>
 * </ul>
 *
 * <p><b>Design Notes:</b>
 * <ul>
 *   <li>Extends {@link AbstractSqlParser} using template method pattern</li>
 *   <li>Uses single parser: {@link TParserAthena}</li>
 *   <li>Primary delimiter: semicolon (;)</li>
 *   <li>Supports PL/SQL-like blocks with BEGIN/END</li>
 * </ul>
 *
 * @see SqlParser
 * @see AbstractSqlParser
 * @see TLexerathena
 * @see TParserAthena
 * @since 3.2.0.0
 */
public class AthenaSqlParser extends AbstractSqlParser {

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

    /** The Athena lexer used for tokenization (note: lowercase 'a' in generated class name) */
    public TLexerathena flexer;

    /** The Athena parser used for parsing */
    private TParserAthena fparser;

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

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

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

        // Create lexer once - will be reused for all parsing operations
        this.flexer = new TLexerathena();
        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 TParserAthena(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) {
        // Athena does not have a secondary parser
        return null;
    }

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

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

    /**
     * Tokenize Athena SQL text into source tokens.
     * <p>
     * Migrated from TGSqlParser.doathenatexttotokenlist() (lines 4664-4694).
     * <p>
     * Handles:
     * <ul>
     *   <li>MySQL-style comment validation</li>
     *   <li>Dynamic delimiter changes (like MySQL DELIMITER command)</li>
     * </ul>
     */
    private void doathenatexttotokenlist() {
        TSourceToken asourcetoken;
        int yychar;
        boolean startDelimiter = false;

        flexer.tmpDelimiter = "";

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

        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();
            }

            yychar = asourcetoken.tokencode;
        }
    }

    /**
     * Check MySQL-style comment tokens.
     * <p>
     * Migrated from TGSqlParser.checkMySQLCommentToken() (lines 4604-4619).
     * <p>
     * Note: This method is mostly a no-op as the validation logic is commented out
     * in the original implementation.
     */
    private void checkMySQLCommentToken(TSourceToken cmtToken) {
        // Original implementation is commented out - keeping as no-op
        // This matches the original TGSqlParser behavior
    }

    // ========== 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) {
        doathenagetrawsqlstatements(builder);
    }

    /**
     * Extract raw SQL statements from token list.
     * <p>
     * Migrated from TGSqlParser.doathenagetrawsqlstatements() (lines 6724+).
     * <p>
     * This method implements a state machine to identify statement boundaries:
     * <ul>
     *   <li>Regular SQL statements terminated by semicolon</li>
     *   <li>PL/SQL-like blocks with BEGIN/END pairs</li>
     *   <li>Slash (/) and period (.) terminators for procedural blocks</li>
     * </ul>
     */
    private void doathenagetrawsqlstatements(SqlParseResult.Builder builder) {
        int waitingEnd = 0;
        boolean foundEnd = false;

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

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

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

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

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

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

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

                    if (gcurrentsqlstatement != null) {
                        if (gcurrentsqlstatement.isathenaplsql()) {
                            gst = EFindSqlStateType.ststoredprocedure;
                            appendToken(gcurrentsqlstatement, ast);
                            foundEnd = false;
                            if ((ast.tokencode == TBaseType.rrw_begin)
                                    || (ast.tokencode == TBaseType.rrw_package)
                                    || (ast.searchToken(TBaseType.rrw_package, 4) != null)) {
                                waitingEnd = 1;
                            }
                        } else {
                            gst = EFindSqlStateType.stsql;
                            appendToken(gcurrentsqlstatement, ast);
                        }
                    } else {
                        // 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;
                        appendToken(gcurrentsqlstatement, ast);
                    }

                    break;
                } // stnormal

                case stsql: {
                    if (ast.tokentype == ETokenType.ttsemicolon) {
                        gst = EFindSqlStateType.stnormal;
                        appendToken(gcurrentsqlstatement, ast);
                        gcurrentsqlstatement.semicolonended = ast;
                        if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE) {
                            System.out.println("  [RAW] Found semicolon, completing statement. Token count=" + gcurrentsqlstatement.sourcetokenlist.size());
                        }
                        onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                        continue;
                    }

                    if (sourcetokenlist.sqlplusaftercurtoken()) { // most probably is / cmd
                        gst = EFindSqlStateType.stnormal;
                        appendToken(gcurrentsqlstatement, ast);
                        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_begin) {
                        waitingEnd++;
                    } 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)) {
                        // Slash terminator
                        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) && (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 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;
                        }
                    }

                    break;
                } // case ststoredprocedure
            }
        }

        // Handle incomplete statement at end of file
        if ((gcurrentsqlstatement != null) &&
                ((gst == EFindSqlStateType.stsql) || (gst == EFindSqlStateType.ststoredprocedure) || (gst == EFindSqlStateType.sterror))) {
            if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE) {
                System.out.println("  [RAW] Incomplete statement at EOF. Token count=" + gcurrentsqlstatement.sourcetokenlist.size());
            }
            onRawStatementComplete(this.parserContext, gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
        }

        // Populate builder with extracted statements (CRITICAL: this was missing!)
        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("AthenaSqlParser.performParsing() CALLED with " +
                (rawStatements != null ? rawStatements.size() : 0) + " statements");
        }

        // Store references
        this.fparser = (TParserAthena) parser;
        this.sourcetokenlist = tokens;
        this.parserContext = context;

        // 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))) {
                    if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE) {
                        System.out.println("AthenaSqlParser: Triggering error recovery for " + stmt.sqlstatementtype);
                        System.out.println("  parseResult=" + parseResult + ", errorCount=" + stmt.getErrorCount());
                        if (stmt.sqlstatementtype == ESqlStatementType.sstcreatetable) {
                            TCreateTableSqlStatement ct = (TCreateTableSqlStatement)stmt;
                            System.out.println("  columns before recovery: " + ct.getColumnList().size());
                        }
                    }
                    handleCreateTableErrorRecovery(stmt);
                    if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE && stmt.sqlstatementtype == ESqlStatementType.sstcreatetable) {
                        TCreateTableSqlStatement ct = (TCreateTableSqlStatement)stmt;
                        System.out.println("  columns after recovery: " + ct.getColumnList().size());
                    }
                }

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

        // Final debug check before returning
        if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE) {
            System.out.println("AthenaSqlParser: total statements = " + sqlstatements.size());
            for (int i = 0; i < sqlstatements.size(); i++) {
                TCustomSqlStatement stmt = sqlstatements.get(i);
                System.out.println("  Statement[" + i + "]: " + stmt.sqlstatementtype + " @ " + System.identityHashCode(stmt));
                if (stmt.sqlstatementtype == ESqlStatementType.sstcreatetable) {
                    TCreateTableSqlStatement ct = (TCreateTableSqlStatement)stmt;
                    System.out.println("    columns = " + ct.getColumnList().size());
                }
            }
        }

        return sqlstatements;
    }

    /**
     * Handle CREATE TABLE error recovery.
     * <p>
     * Migrated from TGSqlParser.doparse() (lines 16914-16971).
     * <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++;
            }
        }

        // For Oracle, validate that the first ignored token is a valid table property
        // For Athena, we don't have this validation, so skip this check
        // (Athena doesn't use searchOracleTablePros)

        // If we found ignoreable tokens, clear errors and retry parsing
        if (isFoundIgnoreToken) {
            if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE) {
                System.out.println("  Found ignoreable tokens, clearing errors and re-parsing...");
            }
            errorSqlStatement.clearError();
            int retryResult = errorSqlStatement.parsestatement(null, false, parserContext.isOnlyNeedRawParseTree());
            if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE) {
                System.out.println("  Retry parse result: " + retryResult);
                if (stmt.sqlstatementtype == ESqlStatementType.sstcreatetable) {
                    TCreateTableSqlStatement ct = (TCreateTableSqlStatement)stmt;
                    System.out.println("  Final column count after retry: " + ct.getColumnList().size());
                }
            }
        }
    }

    // ========== 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();
        }
    }

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

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