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.TLexerImpala;
import gudusoft.gsqlparser.TParserImpala;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSourceTokenList;
import gudusoft.gsqlparser.TStatementList;
import gudusoft.gsqlparser.TSyntaxError;
import gudusoft.gsqlparser.EFindSqlStateType;
import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.ETokenStatus;
import gudusoft.gsqlparser.ESqlStatementType;
import gudusoft.gsqlparser.EErrorType;
import gudusoft.gsqlparser.stmt.TUnknownSqlStatement;
import gudusoft.gsqlparser.sqlcmds.ISqlCmds;
import gudusoft.gsqlparser.sqlcmds.SqlCmdsFactory;
import gudusoft.gsqlparser.compiler.TContext;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.compiler.TGlobalScope;
import gudusoft.gsqlparser.compiler.TFrame;
import gudusoft.gsqlparser.resolver.TSQLResolver;
import gudusoft.gsqlparser.TLog;
import gudusoft.gsqlparser.compiler.TASTEvaluator;

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

/**
 * Apache Impala SQL parser implementation.
 *
 * <p>This parser handles Impala-specific SQL syntax including:
 * <ul>
 *   <li>Hive-compatible SQL dialect</li>
 *   <li>Backtick-quoted identifiers (`schema.table`)</li>
 *   <li>Semicolon statement delimiters</li>
 *   <li>Impala-specific functions and syntax</li>
 * </ul>
 *
 * <p><b>Design Notes:</b>
 * <ul>
 *   <li>Extends {@link AbstractSqlParser} using the template method pattern</li>
 *   <li>Uses {@link TLexerImpala} for tokenization</li>
 *   <li>Uses {@link TParserImpala} for parsing</li>
 *   <li>Shares tokenization logic with Hive (dohivetexttotokenlist)</li>
 *   <li>Delimiter character: ';' for SQL statements</li>
 * </ul>
 *
 * <p><b>Usage Example:</b>
 * <pre>
 * // Get Impala parser from factory
 * SqlParser parser = SqlParserFactory.get(EDbVendor.dbvimpala);
 *
 * // Build context
 * ParserContext context = new ParserContext.Builder(EDbVendor.dbvimpala)
 *     .sqlText("SELECT * FROM employees WHERE dept_id = 10")
 *     .build();
 *
 * // Parse
 * SqlParseResult result = parser.parse(context);
 *
 * // Access statements
 * TStatementList statements = result.getSqlStatements();
 * </pre>
 *
 * @see SqlParser
 * @see AbstractSqlParser
 * @see TLexerImpala
 * @see TParserImpala
 * @since 3.2.0.0
 */
public class ImpalaSqlParser extends AbstractSqlParser {

    /**
     * Construct Apache Impala SQL parser.
     * <p>
     * Configures the parser for Impala database with default delimiter (;).
     * <p>
     * Following the original TGSqlParser pattern, the lexer and parser are
     * created once in the constructor and reused for all parsing operations.
     */
    public ImpalaSqlParser() {
        super(EDbVendor.dbvimpala);
        this.delimiterChar = ';';
        this.defaultDelimiterStr = ";";

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

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

    /** The Impala lexer used for tokenization */
    public TLexerImpala flexer;

    /** Impala parser (for Impala statements) */
    private TParserImpala fparser;

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

    // Note: Global context and frame stack fields inherited from AbstractSqlParser:
    // - protected TContext globalContext
    // - protected TSQLEnv sqlEnv
    // - protected Stack<TFrame> frameStack
    // - protected TFrame globalFrame

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

    /**
     * Return the Impala lexer instance.
     */
    @Override
    protected TCustomLexer getLexer(ParserContext context) {
        return this.flexer;
    }

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

    /**
     * Call Impala-specific tokenization logic.
     * <p>
     * Delegates to doimpalatexttotokenlist which internally calls dohivetexttotokenlist.
     * Impala shares the same tokenization logic as Hive.
     */
    @Override
    protected void tokenizeVendorSql() {
        doimpalatexttotokenlist();
    }

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

        // Update token list for parser
        this.fparser.sourcetokenlist = this.sourcetokenlist;
    }

    /**
     * Call Impala-specific raw statement extraction logic.
     * <p>
     * Delegates to doimpalagetrawsqlstatements which internally calls dohivegetrawsqlstatements.
     * Impala shares the same statement extraction logic as Hive.
     */
    @Override
    protected void extractVendorRawStatements(SqlParseResult.Builder builder) {
        doimpalagetrawsqlstatements(builder);
    }

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

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

        // Initialize statement parsing infrastructure
        this.sqlcmds = SqlCmdsFactory.get(vendor);

        // Inject sqlcmds into parser (required for make_stmt and other methods)
        this.fparser.sqlcmds = this.sqlcmds;

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

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

            try {
                stmt.setFrameStack(frameStack);

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

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

                // Collect syntax errors
                if ((parseResult != 0) || (stmt.getErrorCount() > 0)) {
                    copyErrorsFromStatement(stmt);
                }

            } catch (Exception ex) {
                // Use inherited exception handler from AbstractSqlParser
                // This provides consistent error handling across all database parsers
                handleStatementParsingException(stmt, i, ex);
                continue;
            }
        }

        // Clean up frame stack
        if (globalFrame != null) {
            globalFrame.popMeFromStack(frameStack);
        }

        return this.sqlstatements;
    }

    // Note: initializeGlobalContext() inherited from AbstractSqlParser
    // Note: No override of afterStatementParsed() needed - default (no-op) is appropriate for Impala

    /**
     * Handle error recovery for CREATE TABLE/INDEX statements.
     */
    private void handleCreateTableErrorRecovery(TCustomSqlStatement stmt) {
        if (((stmt.sqlstatementtype == ESqlStatementType.sstcreatetable)
                || (stmt.sqlstatementtype == ESqlStatementType.sstcreateindex))
                && (!TBaseType.c_createTableStrictParsing)) {

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

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

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

    /**
     * Perform Impala-specific semantic analysis using TSQLResolver.
     */
    @Override
    protected void performSemanticAnalysis(ParserContext context, TStatementList statements) {
        if (TBaseType.isEnableResolver() && getSyntaxErrors().isEmpty()) {
            TSQLResolver resolver = new TSQLResolver(globalContext, statements);
            resolver.resolve();
        }
    }

    /**
     * Perform interpretation/evaluation on parsed statements.
     */
    @Override
    protected void performInterpreter(ParserContext context, TStatementList statements) {
        if (TBaseType.ENABLE_INTERPRETER && getSyntaxErrors().isEmpty()) {
            TLog.clearLogs();
            TGlobalScope interpreterScope = new TGlobalScope(sqlEnv);
            TLog.enableInterpreterLogOnly();
            TASTEvaluator astEvaluator = new TASTEvaluator(statements, interpreterScope);
            astEvaluator.eval();
        }
    }

    // ========== Impala-Specific Tokenization ==========

    /**
     * Impala-specific tokenization logic.
     * <p>
     * Extracted from: TGSqlParser.doimpalatexttotokenlist() (line 4600)
     * Delegates to dohivetexttotokenlist as Impala uses the same tokenization as Hive.
     */
    private void doimpalatexttotokenlist() {
        dohivetexttotokenlist();
    }

    /**
     * Hive/Impala-specific tokenization logic.
     * <p>
     * Extracted from: TGSqlParser.dohivetexttotokenlist() (lines 4558-4598)
     * <p>
     * Handles:
     * <ul>
     *   <li>Basic token processing</li>
     *   <li>MAP keyword disambiguation</li>
     *   <li>Backtick-quoted qualified names (`schema.table_name`)</li>
     * </ul>
     */
    private void dohivetexttotokenlist() {
        TSourceToken asourcetoken, lcprevst;
        int yychar;

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

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

            // Handle MAP keyword disambiguation
            if (asourcetoken.tokencode == TBaseType.rrw_map) {
                TSourceToken token = asourcetoken.searchToken(')', -1);
                if (token != null) {
                    asourcetoken.tokencode = TBaseType.ident;
                }
            } else if (asourcetoken.tokencode == '(') {
                // Reserved for future function identification logic
                // TSourceToken token = asourcetoken.searchToken(TBaseType.ident,-1);
                // if (token != null){
                //     token.tokencode = TBaseType.HIVE_FUNC_IDENT;
                // }
            }

            yychar = asourcetoken.tokencode;

            // Handle backtick-quoted qualified names: `schema.table_name`
            if ((asourcetoken.tokencode == TBaseType.ident)
                    && (asourcetoken.toString().startsWith("`")) && (asourcetoken.toString().endsWith("`"))
                    && (asourcetoken.toString().indexOf(".") > 0)) {
                yychar = splitQualifiedNameInBacktick(asourcetoken);
                asourcetoken = null;
            }
        }
    }

    /**
     * Split a backtick-quoted qualified identifier into separate tokens.
     * <p>
     * Extracted from: TGSqlParser.splitQualifiedNameInBacktick() (lines 3458-3503)
     * <p>
     * For example, `schema.table_name` is split into:
     * <ul>
     *   <li>`schema` (identifier)</li>
     *   <li>. (period)</li>
     *   <li>`table_name` (identifier)</li>
     * </ul>
     *
     * @param asourcetoken The qualified identifier token to split
     * @return The token code of the last token created
     */
    private int splitQualifiedNameInBacktick(TSourceToken asourcetoken) {
        int yychar = 0;

        List<String> elephantList = Arrays.asList(TBaseType.getTextWithoutQuoted(asourcetoken.toString()).split("\\."));
        int p = 0, offset = 0;
        for (String s : elephantList) {
            TSourceToken pst = new TSourceToken("`" + s + "`");
            pst.tokencode = asourcetoken.tokencode;
            pst.tokentype = asourcetoken.tokentype;
            pst.tokenstatus = asourcetoken.tokenstatus;
            pst.lineNo = asourcetoken.lineNo;
            pst.columnNo = asourcetoken.columnNo + offset;
            if (p == 0) offset++; // this counts the first ` token
            offset = offset + s.length();
            pst.container = sourcetokenlist;
            if (p > 0) { // For tokens after the first, increment position pointer
                sourcetokenlist.curpos = sourcetokenlist.curpos + 1;
            }
            pst.posinlist = sourcetokenlist.curpos;

            sourcetokenlist.add(pst);
            yychar = pst.tokencode;

            if (p != elephantList.size() - 1) {
                // Add period token between backtick-quoted identifiers
                TSourceToken periodst = new TSourceToken(".");
                periodst.tokencode = '.';
                periodst.tokentype = ETokenType.ttperiod;
                periodst.tokenstatus = asourcetoken.tokenstatus;
                periodst.lineNo = asourcetoken.lineNo;
                periodst.columnNo = asourcetoken.columnNo + offset;
                offset++;
                periodst.container = sourcetokenlist;
                sourcetokenlist.curpos = sourcetokenlist.curpos + 1;
                periodst.posinlist = sourcetokenlist.curpos;
                sourcetokenlist.add(periodst);
                yychar = periodst.tokencode;
            }

            p++;
        }

        return yychar;
    }

    // ========== Impala-Specific Raw Statement Extraction ==========

    /**
     * Impala-specific raw statement extraction logic.
     * <p>
     * Extracted from: TGSqlParser.doimpalagetrawsqlstatements() (lines 11013-11015)
     * Delegates to dohivegetrawsqlstatements as Impala uses the same statement extraction as Hive.
     */
    private void doimpalagetrawsqlstatements(SqlParseResult.Builder builder) {
        dohivegetrawsqlstatements(builder);
    }

    /**
     * Hive/Impala-specific raw statement extraction logic.
     * <p>
     * Extracted from: TGSqlParser.dohivegetrawsqlstatements() (lines 11017-11145)
     * <p>
     * Handles:
     * <ul>
     *   <li>Semicolon statement delimiters</li>
     *   <li>Token adjustments (CHARSET, DATE function, SORT BY)</li>
     *   <li>Continuous semicolons as comments</li>
     *   <li>Error token handling</li>
     * </ul>
     */
    private void dohivegetrawsqlstatements(SqlParseResult.Builder builder) {
        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;

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

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

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

            // Token adjustments specific to Hive/Impala
            if (ast.tokencode == TBaseType.hive_CharSetName) {
                TSourceToken st1 = ast.searchToken(TBaseType.hive_CharSetLiteral, 1);
                if (st1 == null) {
                    ast.tokencode = TBaseType.ident;
                }
            } else if (ast.tokencode == TBaseType.rrw_date) {
                TSourceToken st1 = ast.nextSolidToken();
                if (st1 != null) {
                    if (st1.tokencode == '(') {
                        ast.tokencode = TBaseType.rrw_hive_DATE_FUNCTION;
                    }
                }
            } else if (ast.tokencode == TBaseType.rrw_sort) {
                TSourceToken st1 = ast.searchToken(TBaseType.rrw_by, 1);
                if (st1 == null) {
                    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;
                } //sterror

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

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

                        continue;
                    }

                    gcurrentsqlstatement = sqlcmds.issql(ast, gst, gcurrentsqlstatement);

                    if (gcurrentsqlstatement != null) {
                        gst = EFindSqlStateType.stsql;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                    } else {
                        // error token found

                        this.syntaxErrors.add(new TSyntaxError(ast.getAstext(), ast.lineNo, (ast.columnNo < 0 ? 0 : ast.columnNo)
                                , "Error when 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;
                } // stnormal

                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 stsql

            } //switch
        }//for

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

        // Set results in builder
        builder.sqlStatements(this.sqlstatements);
        builder.errorCode(syntaxErrors.size());
        builder.errorMessage(syntaxErrors.size() == 0 ? "" : String.format("Extraction completed with %d error(s)", syntaxErrors.size()));
    }

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